Book data API

Knowledge & reference · v1.1.0 · openlibrary_books

$0.0004 / book

$0.40 / 1K · pay per delivered book

A book data API over Open Library, the Internet Archive's open catalog of tens of millions of editions. One search returns one row per work: title, authors, first publish year, an ISBN-13 where the catalog holds one, publishers, median page count, community rating with its count, edition count and a cover image URL. Field syntax passes straight through — author:tolkien, isbn:9780261102354, subject:fantasy.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0004 per delivered book · $2 free every month · Failed runs never billed

What it does

What a book data API does

As an ISBN API it works in both directions: an isbn: query resolves a barcode to its work, and every search row carries an isbn column — 13-digit preferred — which is the join key that lines a catalog row up with retail, library or pricing data. Where the catalog holds no ISBN the field is null rather than guessed.

The raw Open Library API is free and keyless, but it returns edition-level documents with dozens of fields formatted for its own website. This returns works — one row each, with an editions count instead of near-duplicate records — which is the deduplicated grain a book database API should hand a pipeline.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	yes	Title, author:…, isbn:…, subject:….
`sort`	string	no	Result order.
`max_results`	integer	no	How many books to deliver at most (1–100). You pay only for delivered books.

Outputs — 22 fields, one row per book

What one book looks like

Every delivered book carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position.
`title`	string	Title.
`authors`	string[]	Authors (up to 5).
`first_publish_year`	integer · nullable	First publication year.
`isbn`	string · nullable	ISBN (13 preferred).
`publishers`	string[]	Publishers (up to 3).
`languages`	string[]	Language codes.
`pages`	integer · nullable	Median page count.
`rating`	number · nullable	Community rating (0-5).
`ratings_count`	integer · nullable	Number of ratings.
`editions`	integer · nullable	Edition count.
`cover_url`	string · nullable	Cover image.
`url`	string	Open Library page.
`subtitle`	string · nullable	Subtitle.
`work_id`	string	Open Library work id (OL…W).
`want_to_read_count`	integer · nullable	Readers who shelved it as want-to-read.
`already_read_count`	integer · nullable	Readers who shelved it as read.
`subjects`	string[]	Subjects (up to 10).
`author_ids`	string[]	Open Library author ids.
`ebook_access`	string · nullable	public, borrowable, printdisabled or no_ebook.
`read_url`	string · nullable	Internet Archive page of the readable/borrowable copy.
`cover_url_large`	string · nullable	Large cover image.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/openlibrary_books/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/openlibrary_books/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/openlibrary_books/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={},
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/openlibrary_books/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the openlibrary_books collector with

Example response

POST /v1/scraper/collectors/openlibrary_books/run

$ curl $QD/openlibrary_books/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{}'
{ "status": "done", "count": 10,
  "results": [
    {
      "title": "…",
      "authors": […],
      "first_publish_year": …,
      "isbn": "…" } ],
  "cost": 0.004 }
# 10 books × $0.0004 · nothing delivered, nothing charged

Try it

Books (Open Library), running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Book data API: from query, QuanticData reads the Open Library records and returns one row per book with title, first_publish_year and isbn, at $0.0004 per delivered book. — You send query and sort; the run reads the source and comes back as books with rank, title and first_publish_year — 22 fields on every row — and you are billed $0.0004 for each book actually delivered, nothing for a run that delivers none.

$0.0004 / book5,000 books on the free $2 every month

Semantic inputquery, sort, max_results — no URL lists

Up to 100books per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

Book data API pricing

$0.0004 per delivered book. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 5,000 books before you spend anything.

$0.0004per delivered book$0.4 per 1,000 delivered books

5,000 bookson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the book data API

Three shapes of work this endpoint was designed around.

Catalog enrichment

Resolve a list of titles or ISBNs into metadata rows — authors, year, publishers, pages — to fill the gaps in a product or library database.

Author bibliographies

An author: query sorted by new returns a publication table for one writer, edition counts included, without touching a retailer.

Ratings-weighted shortlists

Sort a subject: query by rating and keep ratings_count beside the score, so a recommendation set can be filtered by how many readers the rating rests on.

Book data API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Lookup key	Fuzzy title matching and hope	Field queries by author, ISBN and subject
Edition sprawl	Dozens of near-identical edition records	One row per work, with an edition count
Ratings	A separate request per work for scores	Rating and count already on the search row

What people search for

Live autocomplete demand around Books (Open Library), pulled with our own Keyword ideas collector.

Book data API: the POST to the openlibrary_books collector, 100 books delivered and the bill, 100 × $0.0004 = $0.04 in usage.cost_usd; zero books would cost $0. — The same call you would paste into a terminal: a Bearer key, query and sort in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many books arrived and usage.cost_usd is $0.04, which is 100 × $0.0004. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the book data API.

Something else? Ask us

Can I look up a book by ISBN?

Yes — query isbn:9780261102354 and the matching work returns as a normal row. In the other direction, rows carry an ISBN-13 whenever the catalog has one, so book metadata joins onto sales or inventory tables by barcode.

Where does the book data come from?

Open Library, the Internet Archive's community-maintained catalog. Coverage is broad but uneven: fields like page count, rating or ISBN are null where the catalog holds no figure, and the row never pretends otherwise.

Does it return the text of the books?

No — rows are catalog metadata plus a cover image URL, not page content. It builds book datasets and enriches records; reading the books themselves stays on Open Library.

Is there a free book data API?

Every account gets $2 of credit every month with no card, which is about 5,000 delivered books on this endpoint at $0.0004 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0004. A run capped at 100 books — the maximum for this collector — costs $0.04 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the book data API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (Open Library records) turn into clean JSON with the fields title, first_publish_year and isbn; 22 fields on every row.