# ISBN Lookup & Book Search MCP Server (`mrbridge/books-mcp`) Actor

MCP server for book search and ISBN lookup in Claude, ChatGPT, Cursor and VS Code. 9 read-only tools search works by title, author or subject, resolve an ISBN-10 or ISBN-13 to its edition, list editions, tell author namesakes apart and browse subjects, with Open Library as the data source.

- **URL**: https://apify.com/mrbridge/books-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Education
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📚 ISBN Lookup & Book Search MCP Server

ISBN Lookup & Book Search MCP Server gives Claude, ChatGPT, Cursor, VS Code and other MCP clients a book catalogue they can query in plain language. Its 9 read-only tools search works by title, author or subject, resolve an ISBN-10 or ISBN-13 to its edition, list the editions of a book, tell authors with the same name apart and browse a subject by period. The records come from Open Library, and each one links back to its page there. This server is independent and not affiliated with Open Library or the Internet Archive.

Ask Claude "Which book has ISBN 978-0-14-032872-1, who published that edition, and in which other languages was it printed?" It calls `books_get_edition`, which checks the ISBN digits before asking anything, and answers with the title, authors, publisher, date, page count and the work it belongs to. Then `books_list_editions` lists the other editions with their languages and ISBNs. You get a sourced answer in one exchange, without opening a catalogue or copying identifiers by hand.

### What this server exposes

This server wraps the public Open Library APIs (https://openlibrary.org/developers/api) in 9 read-only tools: 7 `books_` tools to search books, read a work and its editions, look up an ISBN, find authors and their works, and browse a subject, plus the `search` and `fetch` pair that ChatGPT deep research expects. Open Library is a catalogue of works and editions run by the Internet Archive, and every answer links each record back to its page on openlibrary.org. The server needs no credentials and no third-party key: you connect with your Apify token, and each successful call is billed as one event. On top of the events you pay the platform usage of your own Standby run, billed to your Apify account: the memory set for the run while the server is up, idle time included, until it stops at its idle timeout (see Pricing). It identifies itself to Open Library with its application name and website, never with your e-mail address. Cover images come as links, never as copies, and author records keep bibliographic facts only.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `books_search` | Search books | `tool-read` |
| `books_get_work` | Get a book | `tool-read` |
| `books_list_editions` | List the editions of a book | `tool-read` |
| `books_get_edition` | Get an edition by ISBN or edition id | `tool-read` |
| `books_search_authors` | Search authors | `tool-read` |
| `books_get_author` | Get an author and their works | `tool-read` |
| `books_browse_subject` | Browse books on a subject | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `books_search`: Search books

Use this when you need to find books (works) in the Open Library catalogue by keywords, title, author or subject, and get their Open Library work id, authors, first publication year, number of editions and cover link. Do not use for one ISBN (books_get_edition), for the details of a known work (books_get_work) or to find a person (books_search_authors). Parameters: `query` (free text, e.g. "the left hand of darkness"), `title`, `author` (e.g. "Ursula K. Le Guin"), `subject` (e.g. "science fiction"), at least one of these four, `language` (ISO 639-1 code such as "fr", keeps works that have an edition in that language), `sort` ("relevance", "new", "old", "editions" for the most published first, "rating"), `limit` (1 to 50), `offset`, `response_format` ("detailed" adds languages, ratings, median page count, subjects and every cover size, at most 20 rows).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"the left hand of darkness"` |
| `title` | string | no | `"the hobbit"` |
| `author` | string | no | `"Ursula K. Le Guin"` |
| `subject` | string | no | `"science fiction"` |
| `language` | string | no | `"fr"` |
| `sort` | "relevance" or "new" or "old" or "editions" or "rating" | no | `"editions"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ works[], pagination, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_get_work`: Get a book

Use this when you have an Open Library work id and need what the book is about: title, authors, first publication date, description, subjects and cover link. Do not use for one edition or an ISBN (books_get_edition), for the list of editions (books_list_editions) or to find a work id (books_search). Parameters: `work_id` (e.g. "OL45804W", or a work page URL), `response_format` ("detailed" adds places, people and times of the subjects, classifications, external links and every cover size). Descriptions are cut to 800 characters. The first publication date is the year of the Open Library search index when it has one, otherwise the date on the work record, and `first_publish_source` says which.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `work_id` | string | yes | `"OL45804W"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ work, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_list_editions`: List the editions of a book

Use this when you need the editions of a book (an Open Library work): publishers, publication dates, ISBN-10 and ISBN-13, page counts, languages and formats, for example to find a translation or a specific printing. Do not use for one ISBN (books_get_edition) or to find the work id (books_search). Parameters: `work_id` (e.g. "OL45804W"), `limit` (1 to 50, default 10), `offset`, `response_format` ("detailed" adds the statement of responsibility, edition name, series, places, contributors, OCLC and LCCN numbers and every cover size, at most 10 rows).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `work_id` | string | yes | `"OL45804W"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ work_id, editions[], pagination, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_get_edition`: Get an edition by ISBN or edition id

Use this when you have an ISBN (10 or 13 digits) or an Open Library edition id and need that edition: title, authors, publisher, publication date, page count, language, format, both ISBNs, cover link and the work it belongs to. Do not use for keyword or title searches (books_search) or for the list of all editions of a book (books_list_editions). Parameters: exactly one of `isbn` (hyphens and spaces allowed, check digit verified, e.g. "978-0-14-032872-1") or `edition_id` (ends in M, e.g. "OL7353617M", or an edition page URL), and `response_format` ("detailed" adds the statement of responsibility, series, places, contributors, OCLC and LCCN numbers and every cover size).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `isbn` | string | no | `"978-0-14-032872-1"` |
| `edition_id` | string | no | `"OL7353617M"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ edition, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_search_authors`: Search authors

Use this when you need to find an author in the Open Library catalogue by name and tell namesakes apart: Open Library author id, birth and death dates, best-known work and number of works. Do not use for books (books_search, which also filters by author name) or when you already have the author id (books_get_author). Parameters: `name` (e.g. "Ursula K. Le Guin" or a family name), `limit` (1 to 50, default 10), `offset`, `response_format` ("detailed" adds alternate names and top subjects, at most 20 rows). Only bibliographic facts are returned, never biographies or photos.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name` | string | yes | `"Ursula K. Le Guin"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ authors[], pagination, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_get_author`: Get an author and their works

Use this when you have an Open Library author id and need the bibliographic facts of the author (name forms, dates, authority identifiers such as Wikidata, VIAF and ISNI) and the works Open Library lists under that author. Do not use for finding the author id (books_search_authors) or for the most published works of an author (books_search with `author` and `sort` "editions", since this list follows Open Library's own order). Parameters: `author_id` (ends in A, e.g. "OL23919A", or an author page URL), `limit` (works per page, 1 to 50, default 20), `offset`, `response_format` ("detailed" adds name forms, identifiers and the subjects of each work). Biographies, photos, links and locations are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `author_id` | string | yes | `"OL23919A"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ author, works[], pagination, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `books_browse_subject`: Browse books on a subject

Use this when you need the books Open Library classifies under one subject (a genre, a topic, a person, a place or a period), with the number of works on that subject, and in detailed mode the related subjects, places, people, periods, prolific authors and publishers. Do not use for free-text searches (books_search with `subject` matches subject words more loosely) or for one book (books_get_work). Parameters: `subject` (an Open Library subject name such as "science fiction", or "place:france", "person:napoleon i", "time:19th century"), `published_in` (a year or a range, e.g. "1900-1950"), `ebooks_only` (true keeps works with an e-book), `limit` (1 to 50, default 10), `offset`, `response_format` ("detailed" adds the related facets and the subjects of each work, at most 20 rows).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `subject` | string | yes | `"science fiction"` |
| `published_in` | string | no | `"1900-1950"` |
| `ebooks_only` | boolean | no | `false` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ subject, works[], related, pagination, next_steps[], attribution }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find books in the Open Library catalogue by title, author, subject or keywords. Do not use for ISBN lookups or for authors as people. Parameter `query` (string), e.g. "the left hand of darkness". Returns up to 10 works with their Open Library work id (e.g. "OL45804W"), a title with authors and year, and the work page URL.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"the left hand of darkness"` |

Returns `{ results[], notices[] }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs the full record of one book returned by search, as text: title, authors, first publication date, subjects, description (cut to 800 characters), cover link and the Open Library page. Do not use for ids that did not come from search or from an Open Library work page URL. Parameter `id`, e.g. "OL45804W" or "https://openlibrary.org/works/OL45804W".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"OL45804W"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: Open Library. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--books-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http books "https://mrbridge--books-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "books": {
      "type": "http",
      "url": "https://mrbridge--books-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--books-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add ISBN Lookup & Book Search MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=ISBN%20Lookup%20%26%20Book%20Search%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--books-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--books-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "books",
  "server_url": "https://mrbridge--books-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--books-mcp.apify.actor/mcp",
      "name": "books",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "books"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/books-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use ISBN Lookup & Book Search MCP Server?

Book questions mix three kinds of record that catalogues keep apart: the work (what the book is), its editions (who printed it, when, under which ISBN) and its authors. This server gives the assistant one tool for each, so the answer says which one it is talking about.

- **ISBNs as people type them.** Hyphens and spaces are fine. The check digit is verified before any request, so a typo answers at once with a clear error, free of charge.
- **Works and editions kept apart.** A work answers with its description, subjects and first publication date. Its editions answer with publisher, date, ISBN-10 and ISBN-13, page count, language and format.
- **Namesakes told apart.** Author search returns birth and death dates, the best-known work and the number of works, then authority identifiers (Wikidata, VIAF, ISNI) on the chosen author.
- **Subjects by period.** Browse a genre, a place, a person or a period, filter by publication years or e-book availability, and see related subjects in detailed mode.
- **Answers you can check.** Every record carries its openlibrary.org link, ChatGPT `search` and `fetch` included.
- 🔌 **Model Context Protocol over Streamable HTTP** at a single endpoint, `https://mrbridge--books-mcp.apify.actor/mcp`, for Claude, ChatGPT, Cursor, VS Code and the OpenAI and Anthropic APIs.
- ⚡ **Apify Standby mode.** The server starts on the first call and stays up until it has been idle for 5 minutes, so the calls of one conversation skip the start.
- **No e-mail asked.** The server identifies itself to Open Library with its own name and website. Your Apify token is the only thing you provide.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **One source.** Everything comes from Open Library. Google Books is not used. Volunteers edit the catalogue, so dates, subjects and descriptions are more complete on some records than on others.
- **Works and editions.** A work groups the editions of one book. `books_search`, `books_get_work` and `books_browse_subject` answer with works, `books_list_editions` and `books_get_edition` with editions (publisher, date, ISBN, pages, language). An edition id ends in M, a work id in W, an author id in A, and a tool given the wrong kind says which tool to use.
- **Slow on purpose.** Open Library allows 1 request per second to clients that do not send a contact e-mail, and this server sends none. It keeps to half of that per instance, caches every answer for a day, and makes two requests for one call at most, three when Open Library merged the record you asked for. A busy moment can answer `UPSTREAM_RATE_LIMITED`: retry a few seconds later.
- **No bulk paging.** Lists stop at 50 rows per call and at the 1,000th result of a query, as Open Library asks API users not to harvest its catalogue. Its monthly data dumps (https://openlibrary.org/developers/dumps) are the place for bulk data.
- **First publication dates.** A work's `first_publish_date` is the first publication year of Open Library's search index when it has one, otherwise the date on the work record, which volunteers type in and which can be wrong (The Lord of the Rings reads "September 3, 2001" there, while the index gives 1954). `first_publish_source` says which of the two you got.
- **Short texts.** Descriptions are cut to 800 characters, titles and names to a few hundred, and lists to their first items. The full record is on the Open Library page given in `openlibrary_url`.
- **Authors.** Author answers keep names, dates, top work, work counts and authority identifiers (Wikidata, VIAF, ISNI, Library of Congress). Biographies, photos, personal links and locations are dropped before anything is cached or returned. A work or an edition names its first 10 authors.
- **Covers.** Cover fields are links to covers.openlibrary.org built from cover ids. This server never downloads or re-hosts an image. Covers can belong to publishers and illustrators: check the rights before reusing one.
- **Merged and deleted records.** When Open Library merged a record into another, the answer is for the new record and says so. A deleted record answers `NOT_FOUND`.
- **Author works order.** `books_get_author` lists works in Open Library's own order. For the most published works of an author, use `books_search` with `author` and `sort` "editions".
- **Attribution.** Every answer carries an `attribution` block that credits Open Library and the Internet Archive and gives the terms and guidelines pages, and every record has its `openlibrary_url`. The ChatGPT answers carry the same lines in `notices`.
- **Affiliation.** This server is not affiliated with or endorsed by Open Library or the Internet Archive.

### Data terms

The records come from Open Library, a project of the Internet Archive. Its Terms of Service are the Internet Archive Terms of Use (https://archive.org/about/terms.php), dated 31 December 2014. They say that access "is granted for scholarship and research purposes only", and they ask users "not to collect or store personal data about anyone". The Open Library API guidelines (https://openlibrary.org/developers/api) add that the APIs "are not intended to serve as a data backend for third-party services" or as "high-traffic commercial infrastructure". The Internet Archive asserts no copyright of its own over the catalogue data (https://openlibrary.org/developers/licensing).

This server is a paid service, which those terms do not cover as written. On 6 October 2026 we wrote to Open Library (openlibrary@archive.org) to ask whether this use is possible and on which terms. We have had no answer so far. If Open Library declines, or asks us to stop, we will remove Open Library from this server, which means retiring the server.

Until then, the server keeps to every other condition of the terms and guidelines: it identifies itself, stays under the published rate limit, caches every answer, refuses bulk paging, never stores author biographies or photos, links every record back to openlibrary.org and never re-hosts a cover. When you reuse what it returns:

- **Keep the link back.** Show each record with its Open Library page (the `openlibrary_url` fields) and credit Open Library.
- **Do not harvest.** Do not use this server to copy the catalogue in bulk. Use the monthly data dumps instead.
- **Respect privacy.** Do not use author data to build profiles of people.
- **Check image rights.** Covers belong to their publishers and illustrators.

The fee for this server pays for the service (hosting, caching, normalisation and the answer format), not for a licence on Open Library data.

### Use cases

**Citation checks.** "Give me the publisher, year, page count and ISBN-13 of the 1969 first edition of The Left Hand of Darkness for my bibliography." The assistant finds the work with `books_search`, then picks the edition from `books_list_editions` and cites its Open Library page.

**Bookshop and library desks.** A customer reads out an ISBN from a phone photo. `books_get_edition` confirms the title, authors and format, and `books_list_editions` shows whether a paperback or a translation exists.

**Which author is it?** "There are several authors called John Williams. Which one wrote Stoner?" `books_search_authors` lists the namesakes with their dates and best-known work, and `books_get_author` lists the works of the right one.

**Reading lists by subject and period.** "Suggest ten science fiction novels first published between 1960 and 1975." `books_browse_subject` filters the subject by years and returns the works with their authors and first publication year.

**Research in ChatGPT.** In deep research, the `search` and `fetch` pair finds books and returns their full record as text, each with the link ChatGPT cites.

### Frequently asked questions

#### Do I need an Open Library account or an API key?

No. You need an Apify account and its API token, nothing else. The server never asks for your e-mail address.

#### How much does a book lookup cost?

Two things are billed to your Apify account. First, the tool calls: $0.005 per successful call, as every tool of this server is a read. This is the price on the Apify Free plan, and the discounts of paid plans lower it. Errors, invalid input such as a wrong ISBN check digit, busy-moment refusals, the spending-limit refusal and protocol traffic (initialize, tool lists, pings) are never charged. Second, the platform usage of your own Standby run, on top of the events: the memory set for the run (256 MB) for as long as the server is up, idle time included, until it stops 5 minutes after your last call, plus a small start event per new run. A 10-minute session of 30 calls comes to $0.15 in tool calls on the Free plan plus 1 to 2 cents of platform usage. Live prices for your Apify plan are on the [Pricing tab](https://apify.com/mrbridge/books-mcp/pricing?fpr=mrbridge), and `maxTotalChargeUsd` caps the event charges of one run.

#### What does the catalogue cover?

Open Library's works, editions, authors and subjects, a catalogue edited by volunteers, so some records are more complete than others. There is no full text, no e-book loan, no price and no Google Books data. Descriptions are cut to 800 characters, and the full record is one click away on the linked Open Library page.

#### Why does a call sometimes answer UPSTREAM_RATE_LIMITED?

Open Library asks API clients to stay at 1 request per second, and this server keeps to half of that. Every answer is cached for a day, so repeated questions come back at once, but a busy moment can refuse a new one. Retry a few seconds later. The refusal is not charged.

#### Can I export lists of books with it?

No. Lists stop at 50 rows per call and at the 1,000th result of a query, as Open Library asks its API users not to harvest the catalogue. For bulk data, Open Library publishes monthly data dumps.

#### What does the server return about authors?

Bibliographic facts only: name forms, birth and death dates as Open Library publishes them, best-known work, work counts and authority identifiers. Biographies, photos, personal links and locations are never returned or stored.

#### Can I reuse the data and the covers?

Keep the link back to each record's Open Library page and credit Open Library. Covers are links to covers.openlibrary.org, never copies, and they belong to their publishers and illustrators, so check the rights before reusing one. The "Data terms" section above explains the terms Open Library data comes with and the request we made to Open Library.

#### Why is my first call slower?

Cold start. After 5 idle minutes the server stops, and the next call waits a few seconds while Apify starts a new run.

#### Is this server affiliated with Open Library?

No. It is an independent server that reads Open Library's public APIs and links every record back to openlibrary.org. It is not affiliated with or endorsed by Open Library or the Internet Archive.

#### Your feedback

Found a wrong record or a broken tool? Open an issue on the [Issues tab](https://apify.com/mrbridge/books-mcp/issues/open?fpr=mrbridge) and it will be looked at. More MCP servers, scrapers and data studies from the same team are on [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.5: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.4: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.3: pricing events tool-read and tool-action. Every tool of this server is a read and bills one `tool-read` event, $0.005 on the Apify Free plan and less on paid plans
- 0.1.2: a work's first publication date is now the year of Open Library's search index when it has one (1954 for The Lord of the Rings, whose work record says September 3, 2001), otherwise the date on the work record, and the new `first_publish_source` field says which. `books_get_work` and `fetch` read it in the same request as the author names, so a call still makes two requests, three after a merge
- 0.1.1: an all-zero placeholder ISBN such as 9780000000002 is refused instead of returning the unrelated edition Open Library files under it, and edition rows no longer list that placeholder as an ISBN. Editions also show the contributors of newer records (translators, illustrators) and take their page count from the page statement when it is the only one, and a related subject that Open Library lists twice now shows once. Test fixtures now come from real Open Library answers captured on the deployed server (private, unpublished)
- 0.1.0: initial build (private, unpublished)
  - server name aligned with the Store title
  - the overview names the platform usage of your own Standby run next to the per-call event, as the Pricing section does

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--books-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--books-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/books-mcp").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 = { "mcpEndpoint": "https://mrbridge--books-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/books-mcp").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mcpEndpoint": "https://mrbridge--books-mcp.apify.actor/mcp"
}' |
apify call mrbridge/books-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/books-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/es7naL2HptMsouMEy/builds/Aydx6IenEBglVPLCG/openapi.json