How to Scrape Google Books: Search, Catalog & ISBN Data

Google Books indexes tens of millions of titles in dozens of languages, and its Volumes API is public and keyless — you can send a search and get JSON back with no credential at all. The catch is everything around a single request: the API paginates 40 items at a time via startIndex, caps every query at 1,000 total results, and returns deeply nested volumeInfo and saleInfo objects that you have to flatten before the data is usable. This guide covers how the Google Books API is structured, how to use its query operators to precision-target a catalog, and how to pull clean book records in bulk without wiring the pagination and JSON-flattening yourself.

What’s worth extracting

The actor flattens each volume into 18 structured fields. Grouped by what you’ll use them for:

• Identity — id (the unique Google Books volume ID), title, subtitle, authors (comma-separated), publisher, publishedDate (YYYY, YYYY-MM or YYYY-MM-DD).
• Content and classification — description (the full editorial synopsis), pageCount, categories (comma-separated BISAC categories), language (ISO 639-1 code like “en” or “fr”).
• Identifiers — isbn10 and isbn13, the fields that make this useful for inventory and price-comparison work.
• Social proof — averageRating (0–5) and ratingsCount.
• Commerce and media — saleability (FOR_SALE, NOT_FOR_SALE, FREE, etc.), listPrice (formatted like “9.99 USD”), previewLink (the Google Books preview URL), thumbnail (cover image URL).

The ISBN pair plus listPrice and saleability is the combination that powers book-store and price-comparison builds; the ratings and categories power editorial and content work.

How the source actually works

The actor talks to the official Google Books Volumes API at https://www.googleapis.com/books/v1/volumes. It has two modes:

• search — keyword-driven full-text search with Google’s query operators, paginated 40 items at a time via startIndex up to the 1,000-result ceiling.
• volumeDetail — fetch specific volumes by their Google Books ID for exact, per-item lookups.

The power move in search mode is Google’s query operators, which let you target instead of post-filter:

• intitle: — match words in the title.
• inauthor: — match by author.
• subject: — match a BISAC category / genre.
• isbn: — exact ISBN lookup (ISBN-10 or ISBN-13).
• inpublisher: — filter by publisher.

They combine freely in one query string. A realistic search-mode input:

{
  "mode": "search",
  "query": "artificial intelligence intitle:machine learning",
  "maxResults": 500,
  "proxy": { "useApifyProxy": true }
}

intitle:deep learning inauthor:Goodfellow returns far cleaner results than a bare deep learning query that’s flooded with tangential volumes. And isbn:9780201616224 pins one exact edition.

For enrichment when you already have IDs (visible in book URLs as books.google.com/books?id=<ID>), switch modes:

{
  "mode": "volumeDetail",
  "ids": ["zyTCAlFPjgYC", "buc0AAAAMAAJ", "ITnFAAAAMAAJ"],
  "proxy": { "useApifyProxy": true }
}

The access reality

Google Books is friendly by scraping standards, but it has hard shape limits you need to design around:

• 1,000 results per query, full stop. The API paginates via startIndex in pages of 40 (25 pages), then stops at 1,000 total items per query — this is a Google-side ceiling, not an actor setting. maxResults accepts values up to 5,000 in the input, but the API caps delivery at 1,000. To cover a broader catalog, run multiple searches with different operators or keywords and merge the results. Slicing by subject:, by author, or by ISBN range gets you past what any single query returns.
• Request pacing is polite by design. The actor fetches 40 books per request with a 200 ms inter-request delay to stay respectful of the API. A full 1,000-book run takes roughly 5–8 minutes depending on proxy speed.
• Datacenter proxy is enough. Google Books does not treat datacenter IPs as hostile for the public search endpoint, so residential proxy is unnecessary — datacenter works well and keeps costs down.
• No key, but also no private data. The actor hits only the unauthenticated Volumes endpoint — the same data any browser visitor sees at books.google.com. It never touches Google Play Books purchase flows or the Partner Center.

▶ Open the Google Books Scraper on Apify — search by keyword, author, subject or ISBN, or fetch exact volumes by ID; 18 fields per book including ISBN-10/13 and list price. Keyless, no login. Export to CSV, JSON or Excel.

Example output

A single volume:

{
  "id": "kqsaBQAAQBAJ",
  "title": "Artificial Intelligence",
  "subtitle": "A Modern Approach",
  "authors": "Stuart Russell, Peter Norvig",
  "publisher": "Prentice Hall",
  "publishedDate": "2010",
  "pageCount": "1152",
  "categories": "Computers",
  "averageRating": "4",
  "ratingsCount": "459",
  "language": "en",
  "isbn10": "0136042597",
  "isbn13": "9780136042594",
  "previewLink": "http://books.google.com/books?id=kqsaBQAAQBAJ&printsec=frontcover",
  "thumbnail": "http://books.google.com/books/content?id=kqsaBQAAQBAJ&printsec=frontcover&img=1&zoom=1",
  "saleability": "FOR_SALE",
  "listPrice": "219.99 USD"
}

Typical use cases

• Niche book databases — build a searchable catalog for a topic (subject:machine learning) and export to Google Sheets for editorial planning.
• ISBN batch enrichment — feed a list of volume IDs in volumeDetail mode to refresh full metadata for existing catalog entries; ideal for inventory reconciliation.
• Rating and trend tracking — run the same category query on a schedule to watch which titles are trending up or fading over time.
• Affiliate content at scale — pull description, thumbnail, publisher and list price for hundreds of books in a subject area to power automated review or comparison pages.
• Academic bibliography building — search inauthor:Sutton subject:reinforcement learning to assemble a curated metadata corpus for a citation-management tool.
• ML datasets — collect labeled book metadata by genre, subject or language for recommendation systems or NLP tasks.

Using the two modes together

The search and volumeDetail modes aren’t alternatives — they’re two halves of a workflow, and the strongest pipelines use both.

Discover with search. Cast the net with operator-narrowed queries to find the volumes you care about and collect their id values. Because each query caps at 1,000 results, you cover a broad catalog by running several targeted searches — subject:machine learning, then subject:deep learning, then inauthor:Goodfellow — and merging the datasets. Slicing by subject, author or ISBN range is how you get past what any single query returns.

Refresh with volumeDetail. Once you have IDs, volumeDetail mode fetches each volume individually for high-accuracy, per-item metadata. This is the mode for inventory reconciliation and for keeping an existing catalog current: you already know exactly which books you’re tracking, so you skip discovery entirely and pull fresh title, price, rating and availability data for each ID. It’s also the cleanest way to enrich a spreadsheet of ISBNs you got from another source — resolve them once via search with isbn:, capture the IDs, then re-pull details on a schedule.

That schedule is the other half of the value. Run the same subject query weekly or monthly with Apify’s scheduler and compare datasets across runs to track new publications, rating movement and price changes in a category. Wire a webhook to the run and you get alerted when something shifts, without watching the catalog by hand.

Non-English catalogs work too. Google Books indexes titles in dozens of languages, and queries in French, German, Spanish, Japanese and others return results in those languages. The language output field carries the ISO 639-1 code, so you can build a language-specific dataset by searching in the target language and filtering the language column post-export.

Cost and effort math

Building this from scratch means handling startIndex pagination in 40-item pages, respecting the 1,000-result ceiling per query, flattening volumeInfo and saleInfo into a flat 18-field row, coping with the many volumes that lack a rating, price or thumbnail, and pacing requests so you don’t hammer the endpoint. It’s a day of work plus maintenance whenever the JSON shape shifts.

The managed actor is pay-per-result — a fraction of a cent per book plus a tiny per-run start fee. Pulling a 500- to 1,000-book subject catalog costs well under a dollar and lands as a spreadsheet. Because datacenter proxy suffices, there’s no residential-bandwidth bill. For a single catalog build you’d never write the pagination glue by hand; for recurring monitoring you schedule the actor and diff the datasets.

Common pitfalls

Specific to the Google Books API:

• The 1,000-result ceiling is per query, not per run. No amount of maxResults gets you past it. To cover a large catalog, split into several operator-narrowed queries and merge — don’t expect one broad search to return everything.
• Null fields are normal. Older titles, academic works and digitized public-domain books frequently lack averageRating, listPrice, pageCount or thumbnail. The actor returns all 18 fields with null for anything missing rather than erroring — plan your schema for it.
• Broad queries return noise. A bare keyword like python drowns you in unrelated volumes. Layer intitle:, inauthor: and subject: to precision-target; it’s far more effective than post-filtering thousands of rows.
• listPrice is a formatted string with a currency. It comes through as “9.99 USD”, not a number. Parse the value and currency separately if you’re doing price math or comparison across regions.
• ISBN search needs the operator. Use isbn:9780201616224 (either ISBN-10 or ISBN-13) for exact-edition lookup; a bare ISBN in the query is treated as a keyword and won’t reliably pin the edition.
• publishedDate granularity varies. It can be a bare year, year-month, or full date depending on the volume. Normalize before sorting chronologically.

Wrapping up

The Google Books Volumes API is a genuinely open, keyless catalog — the friction is entirely in the pagination ceiling and the nested JSON, not in access. If you need a targeted book dataset for a store, a content pipeline or a research corpus, the managed actor lets you express the query with operators and get clean, flattened rows back. For catalog monitoring, schedule it and compare runs over time.

▶ Run the Google Books Scraper on Apify — one run returns up to 1,000 books per query with title, authors, ISBN-10/13, ratings, categories and list price. No API key, no login. Start on Apify’s free monthly credit.