diff --git a/docs/src/js/classes/BlobFile.md b/docs/src/js/classes/BlobFile.md
index 84a596d1a..ee9f9ad28 100644
--- a/docs/src/js/classes/BlobFile.md
+++ b/docs/src/js/classes/BlobFile.md
@@ -10,16 +10,50 @@ A lazy handle to blob bytes. Create one with [Table.fetchBlobFiles](Table.md#fet
 
 ## Methods
 
+### close()
+
+```ts
+close(): Promise<void>
+```
+
+Releases the handle. Reads after `close()` fail. Calling it again does
+nothing.
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
+### isClosed()
+
+```ts
+isClosed(): boolean
+```
+
+Returns true after [BlobFile.close](BlobFile.md#close).
+
+#### Returns
+
+`boolean`
+
+***
+
 ### read()
 
 ```ts
-read(): Promise<Buffer>
+read(maxBytes?): Promise<Buffer>
 ```
 
-Reads from the cursor to the end and advances the cursor.
+Reads from the cursor and advances the cursor.
 
-A second call returns an empty buffer. [BlobFile.readRange](BlobFile.md#readrange) does
-not move the cursor.
+Reads to the end when `maxBytes` is omitted, or at most `maxBytes` bytes
+otherwise. Returns an empty buffer at the end of the blob.
+[BlobFile.readRange](BlobFile.md#readrange) does not move the cursor.
+
+#### Parameters
+
+* **maxBytes?**: `bigint`
 
 #### Returns
 
@@ -49,6 +83,45 @@ Fails when `end` is past the blob size. Does not move the cursor.
 
 ***
 
+### readRanges()
+
+```ts
+readRanges(ranges): Promise<Buffer[]>
+```
+
+Reads several half-open byte ranges. Returns one buffer per range, in
+the order given.
+
+Fails when any `end` is past the blob size. Does not move the cursor.
+
+#### Parameters
+
+* **ranges**: [`BlobRange`](../type-aliases/BlobRange.md)[]
+
+#### Returns
+
+`Promise`&lt;`Buffer`[]&gt;
+
+***
+
+### seek()
+
+```ts
+seek(position): Promise<void>
+```
+
+Moves the cursor to `position`, in bytes from the start of the blob.
+
+#### Parameters
+
+* **position**: `bigint`
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
 ### size()
 
 ```ts
@@ -60,3 +133,17 @@ Returns the blob size in bytes.
 #### Returns
 
 `bigint`
+
+***
+
+### tell()
+
+```ts
+tell(): Promise<bigint>
+```
+
+Returns the cursor position in bytes.
+
+#### Returns
+
+`Promise`&lt;`bigint`&gt;
diff --git a/docs/src/js/globals.md b/docs/src/js/globals.md
index 2f49578b1..9b9f76334 100644
--- a/docs/src/js/globals.md
+++ b/docs/src/js/globals.md
@@ -158,6 +158,7 @@
 - [AnalyzePlanDistributedMetrics](type-aliases/AnalyzePlanDistributedMetrics.md)
 - [BaseTokenizer](type-aliases/BaseTokenizer.md)
 - [BlobOptions](type-aliases/BlobOptions.md)
+- [BlobRange](type-aliases/BlobRange.md)
 - [Data](type-aliases/Data.md)
 - [DataLike](type-aliases/DataLike.md)
 - [FieldLike](type-aliases/FieldLike.md)
diff --git a/docs/src/js/type-aliases/BlobRange.md b/docs/src/js/type-aliases/BlobRange.md
new file mode 100644
index 000000000..85cd48242
--- /dev/null
+++ b/docs/src/js/type-aliases/BlobRange.md
@@ -0,0 +1,27 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / BlobRange
+
+# Type Alias: BlobRange
+
+```ts
+type BlobRange: object;
+```
+
+A half-open byte range `[start, end)` for [BlobFile.readRanges](../classes/BlobFile.md#readranges).
+
+## Type declaration
+
+### end
+
+```ts
+end: bigint;
+```
+
+### start
+
+```ts
+start: bigint;
+```
diff --git a/nodejs/__test__/table.test.ts b/nodejs/__test__/table.test.ts
index ae257455d..64f343cdc 100644
--- a/nodejs/__test__/table.test.ts
+++ b/nodejs/__test__/table.test.ts
@@ -2625,6 +2625,74 @@ describe("when dealing with blob columns", () => {
     ).rejects.toThrow(/exceeds blob size/);
   });
 
+  it("reads at most maxBytes and advances the cursor", async () => {
+    const { table, rowIds } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    expect((await handle!.read(2n)).toString()).toBe("al");
+    expect(await handle!.tell()).toBe(2n);
+    expect((await handle!.read(2n)).toString()).toBe("ph");
+    expect((await handle!.read(10n)).toString()).toBe("a");
+    expect(await handle!.tell()).toBe(5n);
+    expect(await handle!.read(1n)).toEqual(Buffer.alloc(0));
+  });
+
+  it("seeks the cursor", async () => {
+    const { table, rowIds, alpha } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    await handle!.seek(3n);
+    expect(await handle!.tell()).toBe(3n);
+    expect((await handle!.read()).toString()).toBe("ha");
+    await handle!.seek(0n);
+    expect(await handle!.read()).toEqual(alpha);
+  });
+
+  it("rejects a negative seek position", async () => {
+    const { table, rowIds } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    await expect(handle!.seek(-1n)).rejects.toThrow(/cannot be negative/);
+  });
+
+  it("readRanges returns one buffer per range in order", async () => {
+    const { table, rowIds } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    const buffers = await handle!.readRanges([
+      { start: 3n, end: 5n },
+      { start: 0n, end: 2n },
+      { start: 3n, end: 5n },
+    ]);
+    expect(buffers.map((b) => b.toString())).toEqual(["ha", "al", "ha"]);
+    expect(await handle!.tell()).toBe(0n);
+  });
+
+  it("fails when a readRanges end is past the blob size", async () => {
+    const { table, rowIds, alpha } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    await expect(
+      handle!.readRanges([
+        { start: 0n, end: 1n },
+        { start: 0n, end: BigInt(alpha.length + 1) },
+      ]),
+    ).rejects.toThrow(/exceeds blob size/);
+  });
+
+  it("fails reads after close and closes once", async () => {
+    const { table, rowIds } = await openBlobTable();
+    const [handle] = await table.fetchBlobFiles("image", rowIds);
+    expect(handle!.isClosed()).toBe(false);
+    await handle!.close();
+    expect(handle!.isClosed()).toBe(true);
+    await expect(handle!.close()).resolves.toBeUndefined();
+    await expect(handle!.read()).rejects.toThrow(/already closed/);
+    await expect(handle!.read(1n)).rejects.toThrow(/already closed/);
+    await expect(handle!.readRange(0n, 1n)).rejects.toThrow(/already closed/);
+    await expect(handle!.readRanges([{ start: 0n, end: 1n }])).rejects.toThrow(
+      /already closed/,
+    );
+    await expect(handle!.seek(0n)).rejects.toThrow(/already closed/);
+    await expect(handle!.tell()).rejects.toThrow(/already closed/);
+    expect(handle!.size()).toBe(5n);
+  });
+
   it("rejects fetchBlobs on a non-blob column", async () => {
     const { table, rowIds } = await openBlobTable();
     await expect(table.fetchBlobs("id", rowIds)).rejects.toThrow(/blob/i);
diff --git a/nodejs/lancedb/blob.ts b/nodejs/lancedb/blob.ts
index 244faac09..fc8c43196 100644
--- a/nodejs/lancedb/blob.ts
+++ b/nodejs/lancedb/blob.ts
@@ -141,13 +141,14 @@ export class BlobFile {
   }
 
   /**
-   * Reads from the cursor to the end and advances the cursor.
+   * Reads from the cursor and advances the cursor.
    *
-   * A second call returns an empty buffer. {@link BlobFile.readRange} does
-   * not move the cursor.
+   * Reads to the end when `maxBytes` is omitted, or at most `maxBytes` bytes
+   * otherwise. Returns an empty buffer at the end of the blob.
+   * {@link BlobFile.readRange} does not move the cursor.
    */
-  read(): Promise<Buffer> {
-    return this.inner.read();
+  read(maxBytes?: bigint): Promise<Buffer> {
+    return this.inner.read(maxBytes);
   }
 
   /**
@@ -158,8 +159,47 @@ export class BlobFile {
   readRange(start: bigint, end: bigint): Promise<Buffer> {
     return this.inner.readRange(start, end);
   }
+
+  /**
+   * Reads several half-open byte ranges. Returns one buffer per range, in
+   * the order given.
+   *
+   * Fails when any `end` is past the blob size. Does not move the cursor.
+   */
+  readRanges(ranges: BlobRange[]): Promise<Buffer[]> {
+    return this.inner.readRanges(ranges);
+  }
+
+  /** Moves the cursor to `position`, in bytes from the start of the blob. */
+  seek(position: bigint): Promise<void> {
+    return this.inner.seek(position);
+  }
+
+  /** Returns the cursor position in bytes. */
+  tell(): Promise<bigint> {
+    return this.inner.tell();
+  }
+
+  /**
+   * Releases the handle. Reads after `close()` fail. Calling it again does
+   * nothing.
+   */
+  close(): Promise<void> {
+    return this.inner.close();
+  }
+
+  /** Returns true after {@link BlobFile.close}. */
+  isClosed(): boolean {
+    return this.inner.isClosed();
+  }
 }
 
+/** A half-open byte range `[start, end)` for {@link BlobFile.readRanges}. */
+export type BlobRange = {
+  start: bigint;
+  end: bigint;
+};
+
 export function coerceBlobValue(value: unknown): BlobInput | null {
   if (value == null) {
     return null;
diff --git a/nodejs/lancedb/index.ts b/nodejs/lancedb/index.ts
index ed6889232..2e444784b 100644
--- a/nodejs/lancedb/index.ts
+++ b/nodejs/lancedb/index.ts
@@ -84,7 +84,7 @@ export {
 } from "./arrow";
 
 export { blob, isBlobField, BlobFile } from "./blob";
-export type { BlobOptions } from "./blob";
+export type { BlobOptions, BlobRange } from "./blob";
 
 export {
   Connection,
diff --git a/nodejs/src/blob.rs b/nodejs/src/blob.rs
index 230a11bae..413bf6d97 100644
--- a/nodejs/src/blob.rs
+++ b/nodejs/src/blob.rs
@@ -3,6 +3,7 @@
 
 use std::ops::Range;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use arrow_array::{Array, LargeBinaryArray};
 use lancedb::blob::BlobFile as LanceBlobFile;
@@ -11,15 +12,31 @@ use napi_derive::napi;
 
 use crate::error::convert_error;
 
+#[napi(object)]
+pub struct BlobRange {
+    pub start: BigInt,
+    pub end: BigInt,
+}
+
 #[napi]
 pub struct BlobFile {
     inner: Arc<LanceBlobFile>,
+    closed: AtomicBool,
 }
 
 impl BlobFile {
     pub(crate) fn new(inner: LanceBlobFile) -> Self {
         Self {
             inner: Arc::new(inner),
+            closed: AtomicBool::new(false),
+        }
+    }
+
+    fn ensure_open(&self) -> napi::Result<()> {
+        if self.closed.load(Ordering::Acquire) {
+            Err(napi::Error::from_reason("blob file is already closed"))
+        } else {
+            Ok(())
         }
     }
 }
@@ -32,13 +49,23 @@ impl BlobFile {
     }
 
     #[napi]
-    pub async fn read(&self) -> napi::Result<Buffer> {
-        let bytes = self.inner.read().await.map_err(|err| convert_error(&err))?;
+    pub async fn read(&self, max_bytes: Option<BigInt>) -> napi::Result<Buffer> {
+        self.ensure_open()?;
+        let bytes = match max_bytes {
+            None => self.inner.read().await,
+            Some(max_bytes) => {
+                let max_bytes = usize::try_from(parse_u64(max_bytes, "maxBytes")?)
+                    .map_err(|_| napi::Error::from_reason("maxBytes is too large"))?;
+                self.inner.read_up_to(max_bytes).await
+            }
+        }
+        .map_err(|err| convert_error(&err))?;
         Ok(Buffer::from(bytes.as_ref()))
     }
 
     #[napi]
     pub async fn read_range(&self, start: BigInt, end: BigInt) -> napi::Result<Buffer> {
+        self.ensure_open()?;
         let range = bigint_range(start, end)?;
         let bytes = self
             .inner
@@ -47,6 +74,54 @@ impl BlobFile {
             .map_err(|err| convert_error(&err))?;
         Ok(Buffer::from(bytes.as_ref()))
     }
+
+    #[napi]
+    pub async fn read_ranges(&self, ranges: Vec<BlobRange>) -> napi::Result<Vec<Buffer>> {
+        self.ensure_open()?;
+        let ranges = ranges
+            .into_iter()
+            .map(|range| bigint_range(range.start, range.end))
+            .collect::<napi::Result<Vec<_>>>()?;
+        let buffers = self
+            .inner
+            .read_ranges(&ranges)
+            .await
+            .map_err(|err| convert_error(&err))?;
+        Ok(buffers
+            .iter()
+            .map(|bytes| Buffer::from(bytes.as_ref()))
+            .collect())
+    }
+
+    #[napi]
+    pub async fn seek(&self, position: BigInt) -> napi::Result<()> {
+        self.ensure_open()?;
+        let position = parse_u64(position, "position")?;
+        self.inner
+            .seek(position)
+            .await
+            .map_err(|err| convert_error(&err))
+    }
+
+    #[napi]
+    pub async fn tell(&self) -> napi::Result<BigInt> {
+        self.ensure_open()?;
+        let position = self.inner.tell().await.map_err(|err| convert_error(&err))?;
+        Ok(BigInt::from(position))
+    }
+
+    #[napi]
+    pub async fn close(&self) -> napi::Result<()> {
+        if self.closed.swap(true, Ordering::AcqRel) {
+            return Ok(());
+        }
+        self.inner.close().await.map_err(|err| convert_error(&err))
+    }
+
+    #[napi]
+    pub fn is_closed(&self) -> bool {
+        self.closed.load(Ordering::Acquire)
+    }
 }
 
 fn bigint_range(start: BigInt, end: BigInt) -> napi::Result<Range<u64>> {