# Open Library Editions Scraper (`parseforge/openlibrary-editions-scraper`) Actor

Pull physical book editions (ISBNs, publishers, page counts, formats, languages) from Open Library. Direct ISBN lookup OR pull every edition of a work by OL key. Bulk-friendly for libraries, publishers, booksellers, and ISBN-to-book pipelines. Returns 30+ fields per edition.

- **URL**: https://apify.com/parseforge/openlibrary-editions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📚 Open Library Editions Scraper

> 🚀 **Pull physical book editions (ISBNs, publishers, page counts, formats, languages) from Open Library.**

> 🕒 **Last updated:** 2026-05-06 · **📊 32 fields** per record · **Bulk ISBN lookup or per-work edition pulls** · publishers, ISBNs, page counts, formats, languages, places, dimensions, classifications

The **Open Library Editions Scraper** pulls physical book-edition records from the Internet Archive's Open Library catalog. While most catalog tools focus on abstract works, this Actor returns the concrete editions: each printing's ISBN-10, ISBN-13, publisher, place of publication, page count, physical format, dimensions, language, and library classifications.

Two input modes in one Actor: (1) provide a list of ISBNs and the Actor resolves each directly to a structured edition record; or (2) provide an Open Library work key and the Actor pulls every edition of that work, optionally filtered by language or publisher.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Library systems, publishers, booksellers, ISBN-to-book pipelines, OPAC integrations, second-hand marketplaces | Catalog enrichment, ISBN bulk lookup, publisher analysis, edition reconciliation, Library of Congress and Dewey classification join-keys |

---

### 📋 What the Open Library Editions Scraper does

Five filtering workflows in a single run:

- 🆔 **ISBN bulk lookup.** Provide hundreds of ISBNs (ISBN-10 or ISBN-13). Each resolves to a full edition record.
- 📚 **Per-work editions.** Pass an OL work key (e.g. `OL45804W`) and pull every published edition of that work.
- 🌐 **Language filter.** ISO 639-2 code restricts edition results from a work.
- 🏢 **Publisher filter.** Substring-match on publisher to narrow a work's editions.
- 📋 **Library classifications.** Dewey Decimal, LC Classification, OCLC, and source records included.

> 💡 **Why it matters:** clean, server-side filtering removes the parser-and-pagination work from your team and keeps your dataset fresh on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>isbns</code></td><td>string</td><td><code>newline/semicolon list</code></td><td>ISBN-10 or ISBN-13 codes, one per line. Resolved directly.</td></tr>
<tr><td><code>workKey</code></td><td>string</td><td><code>""</code></td><td>Open Library work key (e.g. `OL45804W`) for full edition list.</td></tr>
<tr><td><code>language</code></td><td>string</td><td><code>""</code></td><td>ISO 639-2 (eng, spa, fre).</td></tr>
<tr><td><code>publisher</code></td><td>string</td><td><code>""</code></td><td>Publisher name substring filter.</td></tr>
</tbody>
</table>

**Example: lookup 3 ISBNs.**

```json
{
    "maxItems": 100,
    "isbns": "9780544003415\n9780142418222\n9780261103573"
}
````

**Example: every English Penguin edition of a work.**

```json
{
    "maxItems": 100,
    "workKey": "OL45804W",
    "language": "eng",
    "publisher": "Penguin"
}
```

***

### 📊 Output

Each record contains **32 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `coverUrl` | string | null | `"https://covers.openlibrary.org/b/id/12345-L.jpg"` |
| 🆔 `editionKey` | string | `"OL44247403M"` |
| 🆔 `workKey` | string | null | `"OL45804W"` |
| 📛 `title` | string | `"Fantastic Mr. Fox"` |
| 📛 `subtitle` | string | null | `"A novel"` |
| 🆔 `isbn13` | string | null | `"9780142418222"` |
| 🆔 `isbn10` | string | null | `"0142418226"` |
| 🏢 `publishers` | array | `["Penguin Publishing Group","Puffin"]` |
| 📍 `publishPlaces` | array | null | `["New York"]` |
| 📅 `publishDate` | string | null | `"2007"` |
| 📖 `numberOfPages` | number | null | `96` |
| 📐 `physicalFormat` | string | null | `"Paperback"` |
| 📐 `physicalDimensions` | string | null | `"7.7 x 5.1 x 0.3 inches"` |
| 🌐 `languages` | array | `["eng"]` |
| 🆔 `deweyDecimal` | array | null | `["[Fic]"]` |
| 🆔 `lcClassifications` | array | null | `["PZ7.D1515 Fan 2007"]` |
| 🆔 `oclcNumbers` | array | null | `["86113556"]` |
| 🔗 `openLibraryUrl` | string | `"https://openlibrary.org/books/OL44247403M"` |

#### 📦 Sample records

<details>
<summary><strong>📕 Trade paperback</strong></summary>

```json
{"editionKey":"OL44247403M","workKey":"OL45804W","title":"Fantastic Mr. Fox","publishers":["Penguin Publishing Group","Puffin"],"isbn13":"9780142418222","publishDate":"2007","numberOfPages":96,"physicalFormat":"Paperback","languages":["eng"]}
```

</details>

<details>
<summary><strong>📘 Foreign edition</strong></summary>

```json
{"editionKey":"OL40343425M","workKey":"OL45804W","title":"Fantastic Mr. Fox","publishers":["Penguin Random House"],"isbn13":"9780224032728","languages":["eng"]}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🆔 | **ISBN-first.** Built for bulk catalog enrichment from ISBN lists, not generic search. |
| 📚 | **Edition-level metadata.** Returns the concrete physical-edition primitive with publisher, ISBN, page count, dimensions. |
| 🌐 | **Library classifications.** Dewey, LC, OCLC, and source records join cleanly to OPAC and library systems. |
| ⚡ | **Fast.** 100 records in under 30 seconds. |
| ⚖️ | **Public domain catalog.** Open Library publishes under CC; commercial reuse permitted. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | Edition-level | Live per run | ISBN list, work key, lang, publisher | ⚡ 2 min |
| Manual Open Library browse | Free | Manual | Live | Web filters | 🕒 Manual |
| Google Books API | Free | Curated | Live | Limited | 🐢 Quota |
| ISBNdb | $15+/month | Editions | Stale | Limited | 🐢 Account |

Pick this Actor when you want broad coverage, server-side filtering, and no pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Open Library Editions Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick your filters and `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📚 Library Tech

- ISBN-to-edition catalog enrichment
- Dewey/LC classification joins
- Bulk-import OPAC entries
- Reconcile editions across vendors

</td>
<td width="50%" valign="top">

#### 🛒 Booksellers & Publishers

- Map customer ISBN lists to full metadata
- Verify edition stock against vendor catalogs
- Build publisher-level analytics
- Power second-hand-marketplace listings

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎓 Education

- Reading-list ISBN resolution
- Course-pack catalog enrichment
- Citation generation per edition
- ISBN audit for syllabus updates

</td>
<td width="50%" valign="top">

#### 🤖 ML & Data Pipelines

- Train book-recommendation models
- Build ISBN→work clustering
- Catalog deduplication research
- Multi-source bibliographic reconciliation

</td>
</tr>
</table>

***

### 🔌 Automating Open Library Editions Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep downstream databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Bibliographic research with edition primitives
- Citation generation
- Cross-edition translation studies
- Reproducible catalog snapshots

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal book-collection cataloging
- Indie publisher portfolios
- Reading-app side projects
- Hobbyist library management

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Library digitization projects
- Open-data catalog contributions
- Multilingual reading-list outreach
- Cultural preservation

</td>
<td width="50%">

#### 🧪 Experimentation

- Train book-deduplication models
- Test ISBN resolution accuracy
- Prototype catalog-search experiments
- Build edition-recommendation engines

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Open%20Library%20Editions%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Open%20Library%20Editions%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Open%20Library%20Editions%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Open%20Library%20Editions%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Provide an ISBN list, a work key, or both. The Actor queries the Open Library edition endpoints and emits one structured record per edition.

#### 🆔 What's the difference between work and edition?

A work is the abstract book (e.g. Lord of the Rings). An edition is a specific printing (1965 Houghton Mifflin hardback, 2003 Mariner trade paperback, 2014 graphic novel adaptation, etc.). Each edition has its own ISBN, page count, and publisher.

#### 📊 How many fields per record?

32, including title, ISBN-10/13, publishers, places, page count, format, dimensions, languages, Dewey/LC classifications, OCLC numbers, and direct URL.

#### 📚 Can I get every edition of a book?

Yes. Pass the work key (`OL45804W`) and the Actor paginates through all editions, optionally filtered by language or publisher.

#### 🌐 Which languages are covered?

60+, including all major European and Asian languages plus less-common ones with smaller catalogs.

#### 🔁 Can I schedule runs?

Yes. Use Apify Schedules to refresh catalog enrichments daily, weekly, or after each batch of new ISBNs.

#### ⚖️ Is this data free to use?

Yes. Open Library publishes its catalog under a Creative Commons license that permits commercial use with attribution.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs. A paid plan unlocks higher item counts and scheduling.

#### 🆘 What if a run fails?

Apify retries transient errors. Inspect logs in the Runs tab; partial datasets are preserved.

#### 🔢 What if an ISBN isn't in Open Library?

Open Library covers most published books with ISBNs but isn't exhaustive. Missing ISBNs are skipped with a warning, not failures.

***

### 🔌 Integrate with any app

Open Library Editions Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**📖 Project Gutenberg Books**](https://apify.com/parseforge/project-gutenberg-books-scraper) - 75,000+ free public-domain books
- [**🌐 Wikidata Entity Search**](https://apify.com/parseforge/wikidata-entity-search-scraper) - 100M+ open knowledge-graph entities
- [**🎨 Openverse Media**](https://apify.com/parseforge/openverse-media-scraper) - 800M+ openly licensed images and audio
- [**📊 Stack Exchange Questions**](https://apify.com/parseforge/stackexchange-questions-scraper) - Search 170+ Stack Exchange sites
- [**📰 HN Who's Hiring Jobs**](https://apify.com/parseforge/hn-whoishiring-scraper) - Monthly Ask HN: Who is hiring? threads parsed

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Internet Archive, Open Library, or any contributing library or publisher. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `isbns` (type: `string`):

ISBN-10 or ISBN-13 codes, one per line or semicolon-separated. Resolved directly to edition records.

## `workKey` (type: `string`):

Open Library work key (e.g. `OL45804W`) to pull every published edition of that work.

## `language` (type: `string`):

ISO 639-2 code (e.g. `eng`, `spa`, `fre`). Filters edition results from a work.

## `publisher` (type: `string`):

Publisher name substring filter when pulling editions of a work.

## Actor input object example

```json
{
  "maxItems": 10,
  "isbns": "9780544003415\n9780142418222\n9780261103573"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "isbns": `9780544003415
9780142418222
9780261103573`,
    "workKey": "",
    "language": "",
    "publisher": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openlibrary-editions-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "isbns": """9780544003415
9780142418222
9780261103573""",
    "workKey": "",
    "language": "",
    "publisher": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openlibrary-editions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "isbns": "9780544003415\\n9780142418222\\n9780261103573",
  "workKey": "",
  "language": "",
  "publisher": ""
}' |
apify call parseforge/openlibrary-editions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/openlibrary-editions-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Library Editions Scraper",
        "description": "Pull physical book editions (ISBNs, publishers, page counts, formats, languages) from Open Library. Direct ISBN lookup OR pull every edition of a work by OL key. Bulk-friendly for libraries, publishers, booksellers, and ISBN-to-book pipelines. Returns 30+ fields per edition.",
        "version": "1.0",
        "x-build-id": "ICdHpHA1NrcioqCan"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openlibrary-editions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openlibrary-editions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~openlibrary-editions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openlibrary-editions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~openlibrary-editions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openlibrary-editions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "isbns": {
                        "title": "ISBN list",
                        "type": "string",
                        "description": "ISBN-10 or ISBN-13 codes, one per line or semicolon-separated. Resolved directly to edition records."
                    },
                    "workKey": {
                        "title": "Work key",
                        "type": "string",
                        "description": "Open Library work key (e.g. `OL45804W`) to pull every published edition of that work."
                    },
                    "language": {
                        "title": "Edition language filter",
                        "type": "string",
                        "description": "ISO 639-2 code (e.g. `eng`, `spa`, `fre`). Filters edition results from a work."
                    },
                    "publisher": {
                        "title": "Publisher filter",
                        "type": "string",
                        "description": "Publisher name substring filter when pulling editions of a work."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
