Goodreads Book Scraper With Full Book Details

Goodreads Book Scraper — Extract Books, Editions and Author Profiles

Goodreads Book Scraper With Full Book Details turns a Goodreads book search into a structured dataset. Every matching book comes back with its full edition record — ISBN, ISBN13, ASIN, format, page count, language, publisher, publication date, genres and series placement — plus the author's Goodreads profile and, optionally, its readers-also-enjoyed titles as linked rows. Unlike scraping frameworks that return raw HTML, this Actor returns typed JSON, ready for your model, your database or your pipeline without any parsing. This guide covers every input and output field, plus how publishing, research and AI teams run it.

🧭 What Does Goodreads Book Scraper With Full Book Details Do?

Goodreads Book Scraper With Full Book Details is an Apify Actor that runs one or more Goodreads book searches, then enriches every result with the full edition record Goodreads' own search listing never shows. No Goodreads account or API key is required — the Actor only reads publicly visible search and book pages. It writes two row types into one dataset: book rows (search result plus full details) and, optionally, similarBook rows for each title's readers-also-enjoyed recommendations.

• 📚 Book search results — title, author, printed rating and ratings-count text, publication year and edition count for every match
• 🔖 Full edition record — ISBN, ISBN13, ASIN, format, page count, language, publisher and publication date
• 🏷️ Genre and series data — genre shelf names, series title, series position and series URL
• 🧾 Book description — the full blurb text
• ✍️ Author profile — Goodreads author page URL, biography, total works count and follower count
• 🧭 Similar books — readers-also-enjoyed titles as extra rows linked back to their parent book
• ⭐ Typed and raw values together — the exact printed rating / ratingsCount / published / editions text alongside numeric ratingValue / ratingsCountValue / publishedYear / editionsCount

⚡ Features & Capabilities

Capabilities split into three groups: what gets scraped, how deep the enrichment goes, and how the run behaves when Goodreads pushes back.

Core features

• Multi-search input — one Goodreads search phrase or search URL per line via bookSearchTerms, each tagged in the output by searchQuery and searchRank
• Full edition lookup — isbn, isbn13, asin, format, numPages, language, publisher, publicationDate resolved from Goodreads' own book-record service for every book, not scraped off the listing
• Genre and series data — genres array, seriesName, seriesPosition, seriesUrl
• Author profile — authorUrl, authorBio, authorWorksCount, authorFollowersCount
• Similar-book rows — type: "similarBook" rows linked to their parent via parentBookId and parentTitle, with a similarBooksCount roll-up on the parent book row
• Typed and raw values together — ratingValue / ratingsCountValue / publishedYear / editionsCount as numbers alongside the original rating / ratingsCount / published / editions text
• Legacy input compatibility — urls and resultsPerQuery still work if bookSearchTerms / booksPerSearch are left empty
• Live dataset writes — every row is pushed the moment it's collected, so a stopped run still keeps everything gathered so far

When another tool might suit you better

This Actor is built for book metadata, not review mining — it returns textReviewsCount but not the review text itself, so a scraper purpose-built for pulling full review bodies is the better fit if that's your goal. It also works from search results, one query at a time; if you need every edition of a single author's entire bibliography without running a search per title, an author-bibliography-first approach would get there in fewer requests. For ISBN-to-metadata enrichment, genre and series data, and author profiles from search terms in one pass, this is the more direct route.

Goodreads Book Scraper With Full Book Details within the Scrapio data stack

Goodreads Book Scraper With Full Book Details is currently Scrapio's only Goodreads Actor — it covers book search results, full edition records, genre and series data, author profiles and similar-book recommendations in a single run, so there's no need to combine multiple Goodreads tools for these entity types. If your workflow also needs pricing or availability for the same titles on Amazon, Scrapio's Amazon Product Details & Variant ASINs Scraper can be paired using the asin this Actor already returns.

Why do developers and data teams scrape Goodreads?

🏢 Publishers and booksellers

A publisher or bookseller feeds a list of titles or ISBNs into bookSearchTerms and matches the results against their own catalog by isbn / isbn13. format, numPages, publisher and publicationDate let a team compare how many editions of a book are listed, in which formats and languages, and whether a new edition has shipped since the last check. genres and seriesName / seriesPosition support shelving and series-completeness checks across a backlist without opening each book page by hand.

📊 AI training data and RAG indexing

description and authorBio are this dataset's high-information text fields — long-form, unstructured, and the ones worth embedding for retrieval. For RAG, indexing description alongside title, author and genres lets a book-recommendation or library-assistant agent answer "books like X" questions with grounded, current metadata instead of a stale model prior. For training data, isbn13, format, numPages, language, genres and seriesPosition are the fields with the most consistent structure across records, since they come from Goodreads' own edition record rather than free-text parsing.

📱 Competitive and market intelligence

Run the same search lines on a schedule and track ratingValue, ratingsCountValue, textReviewsCount and editionsCount over time to see how a title's reception and edition count move. Watching genres across a topic search (e.g. a genre or category term) surfaces which shelves a title is actually being placed on by readers, which is a market signal a static catalog feed doesn't give you.

🔬 Research and academic use

Literature, publishing and genre-trend research can build a dataset from a list of search terms — genre keywords, author names, or a themed reading list — and get consistent genres, seriesName, ratingValue and publishedYear fields for analysis. All of it is data Goodreads already shows to any visitor; no account is read or created.

🎥 Product and SaaS development

Reading-recommendation apps, library-enrichment tools and personal-library trackers can build directly on the similarBook rows for a recommendation graph and on the full edition record for catalog display, without maintaining their own Goodreads scraping code.

🍚 Input Parameters

All parameters are read from .actor/actor.json. Nothing in the schema is marked required, but the run raises an error immediately if both bookSearchTerms and urls come back empty — in practice, one search line is required.

Parameter	Required	Type	Description	Example Value
bookSearchTerms	No	array (stringList)	One book search phrase or a full Goodreads book-search URL per line. Every line is scraped separately and tagged in the output via searchQuery.	["python programming", "the hunger games"]
booksPerSearch	No	integer, min 1, max 10000	How many books to collect for EACH line above. Result pages are walked until this count is reached or the search runs out of books. Similar-book rows do not count towards it. Falls back to resultsPerQuery, then to 10, when left empty.	25
maxBooksTotal	No	integer, min 0, default 0	Hard ceiling on books across ALL search lines combined. 0 = no ceiling.	40
fetchFullBookDetails	No	boolean, default true	ON adds ISBN / ISBN13 / ASIN, format, page count, language, publisher, publication date, genres, series and large cover to every book. OFF returns the plain search-listing fields only.	true
includeBookDescription	No	boolean, default true	Adds the full book blurb text to each row. Needs fetchFullBookDetails ON.	true
includeAuthorProfile	No	boolean, default true	Adds the author's Goodreads page URL, biography, total published works and follower count to each book row. Needs fetchFullBookDetails ON.	false
includeSimilarBooks	No	boolean, default false	ON adds a separate row per similar title, linked to its parent book, plus a similarBooksCount column on the book row.	true
maxSimilarBooksPerBook	No	integer, min 1, max 20, default 5	Caps how many similar titles are kept for each book. Only used when includeSimilarBooks is ON.	10
urls	No	array (stringList, legacy key)	Same meaning as bookSearchTerms. Used only when bookSearchTerms is empty.	["https://www.goodreads.com/search?q=dune&search_type=books"]
resultsPerQuery	No	integer, min 1, max 10000 (legacy key)	Same meaning as booksPerSearch. Used only when booksPerSearch is empty.	20
requestDelayMs	No	integer, min 0, max 60000	Milliseconds to wait between two result pages of the same search. Default 1000.	1500
proxyConfiguration	No	object (proxy editor)	Optional Apify Proxy settings. useApifyProxy (boolean) turns proxy routing on from the first request; apifyProxyGroups (array of strings) selects proxy groups; apifyProxyCountry (string, ISO-2) filters by exit country.	{"useApifyProxy": true, "apifyProxyCountry": "US"}

Two behaviours worth knowing before you run it: maxSimilarBooksPerBook tops out at 20 because Goodreads' own recommendation lookup returns at most 20 similar titles per book — asking for more wouldn't return more. And the source also reads a delayMs key as a fallback for requestDelayMs if the newer key is left empty; it isn't in the published schema, so treat it as an unofficial alias rather than something to rely on.

Example input

{
  "bookSearchTerms": ["python programming", "the hunger games"],
  "booksPerSearch": 25,
  "maxBooksTotal": 40,
  "fetchFullBookDetails": true,
  "includeBookDescription": true,
  "includeAuthorProfile": true,
  "includeSimilarBooks": true,
  "maxSimilarBooksPerBook": 5,
  "requestDelayMs": 1000,
  "proxyConfiguration": { "useApifyProxy": false }
}

Supported URL types and input formats

• A plain search phrase — "python programming". The Actor builds a Goodreads book-search URL from it and pages through the results.
• An ISBN as a search phrase — "9780439023481". Goodreads' own search box treats a numeric ISBN like any other query, so a line like this works the same way a title does.
• A full Goodreads search URL — "https://www.goodreads.com/search?q=dune&search_type=books". Recognized because it starts with http and contains goodreads.com/search; the Actor rewrites its page parameter and pages through it exactly like a plain search.

📦 Output Format

Every row — book or similarBook — is pushed to the dataset the moment it's collected, using the same 43-key shape either way; fields that don't apply to a row come back as null rather than a placeholder. Fields Goodreads genuinely doesn't have for a given edition (an ebook with no ISBN, a standalone book with no series) are also null, never omitted or filled in.

Output for a book row (type: "book")

{
  "type": "book",
  "isChild": false,
  "bookId": "2767052",
  "title": "The Hunger Games",
  "author": "Suzanne Collins",
  "authorUrl": "https://www.goodreads.com/author/show/153394.Suzanne_Collins",
  "ratingValue": 4.34,
  "ratingsCountValue": 9798081,
  "textReviewsCount": 197560,
  "isbn13": "9780439023481",
  "isbn": "0439023483",
  "asin": "0439023483",
  "format": "Hardcover",
  "numPages": 374,
  "language": "English",
  "publisher": "Scholastic Press",
  "publicationDate": "2008-09-14",
  "publishedYear": 2008,
  "editionsCount": 100,
  "genres": ["Young Adult", "Fiction", "Dystopia", "Science Fiction"],
  "seriesName": "The Hunger Games",
  "seriesPosition": "1",
  "seriesUrl": "https://www.goodreads.com/series/73758-the-hunger-games",
  "description": "Winning will make you famous. Losing means certain death...",
  "authorBio": "Suzanne Collins is the author of the bestselling Underland Chronicles...",
  "authorWorksCount": 73,
  "authorFollowersCount": 121000,
  "similarBooksCount": 5,
  "parentBookId": null,
  "parentTitle": null,
  "detailsStatus": "ok",
  "searchQuery": "the hunger games",
  "searchRank": 1,
  "url": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
  "coverUrl": "https://images-na.ssl-images-amazon.com/images/S/compressed.photo.goodreads.com/books/1586722975l/2767052._SX50_.jpg",
  "highResCoverUrl": "https://images-na.ssl-images-amazon.com/images/S/compressed.photo.goodreads.com/books/1586722975i/2767052.jpg",
  "workId": "2792775",
  "originalTitle": "The Hunger Games",
  "rating": "4.34",
  "ratingsCount": "9,798,081",
  "published": "2008",
  "editions": "100",
  "scrapedAt": "2026-08-15T09:00:00Z"
}

Output for a similar-book row (type: "similarBook")

{
  "type": "similarBook",
  "isChild": true,
  "bookId": "3636",
  "title": "The Giver",
  "author": "Lois Lowry",
  "authorUrl": null,
  "ratingValue": 4.13,
  "ratingsCountValue": 2456789,
  "textReviewsCount": null,
  "isbn13": null,
  "isbn": null,
  "asin": null,
  "format": null,
  "numPages": null,
  "language": null,
  "publisher": null,
  "publicationDate": null,
  "publishedYear": null,
  "editionsCount": null,
  "genres": null,
  "seriesName": null,
  "seriesPosition": null,
  "seriesUrl": null,
  "description": null,
  "authorBio": null,
  "authorWorksCount": null,
  "authorFollowersCount": null,
  "similarBooksCount": null,
  "parentBookId": "2767052",
  "parentTitle": "The Hunger Games",
  "detailsStatus": "not_applicable",
  "searchQuery": "the hunger games",
  "searchRank": 1,
  "url": "https://www.goodreads.com/book/show/3636.The_Giver",
  "coverUrl": "https://images-na.ssl-images-amazon.com/images/S/compressed.photo.goodreads.com/books/1342493368l/3636.jpg",
  "highResCoverUrl": null,
  "workId": null,
  "originalTitle": null,
  "rating": null,
  "ratingsCount": null,
  "published": null,
  "editions": null,
  "scrapedAt": "2026-08-15T09:00:05Z"
}

Schema stability and export options

Field names stay stable across runs regardless of how Goodreads reshuffles its front end, because the full edition record comes from Goodreads' own book-record service rather than being scraped off rendered HTML — only the base search-listing fields (title, author, rating, ratingsCount, published, editions, url, coverUrl) are parsed from the page itself. When a book's full record can't be retrieved on a given run, detailsStatus reports unavailable and the detail fields come back null rather than a stale or guessed value — nothing is silently dropped. Dataset rows export from the Apify Console to JSON, CSV, Excel or XML, or can be pulled programmatically through the Apify API and apify_client. Each run also writes a SUMMARY.json record to the run's key-value store with total_items, books, similarBooks, queries, booksPerSearch, maxBooksTotal, fullBookDetails and similarBooksIncluded.

💡 Goodreads Book Scraper With Full Book Details Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new ISBN or title lands in your system — a new acquisition, a catalog import, a user-submitted book. Pass it as one line in bookSearchTerms with fetchFullBookDetails ON, run the Actor, then read isbn13, format, numPages, publisher, genres and seriesName off the returned row and write them back into your own record. Because rows are pushed live, a single-book enrichment call finishes as soon as that one row lands in the dataset.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify schedule to re-run the same search lines weekly or monthly. Diff each new run's ratingValue, ratingsCountValue, textReviewsCount and editionsCount against the previous run's values for the same bookId, and alert when a title crosses a threshold you set — a ratings-count jump, a new edition appearing, a genre shelf changing. scrapedAt on every row gives you the timestamp to key the diff on.

🎯 Strategy 3: Bulk dataset build

Put a long list of search terms — genre keywords, an author roster, a themed reading list — into bookSearchTerms, set booksPerSearch and maxBooksTotal to size the run, and export the finished dataset to CSV once it completes. Since every row (book or similarBook) is charged as one row_result event, maxBooksTotal and maxSimilarBooksPerBook are your two direct levers for keeping a large build inside a fixed budget; turning fetchFullBookDetails off trims the run to listing-only fields when you just need a wide, fast sweep.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Filling in ISBN/edition data as records arrive	One search line per run, triggered on demand	Live dataset rows, read back immediately
Scheduled monitoring	Tracking rating and edition changes over time	Same search lines, re-run on an Apify schedule	Dataset rows diffed run-over-run on bookId
Bulk dataset build	Building a research or catalog dataset	Long search-term list, one run	Dataset exported to CSV / JSON at completion

🌴 Related Goodreads Scrapers & Tools

Goodreads Book Scraper With Full Book Details is currently Scrapio's only Goodreads-focused Actor, so there's no sibling Goodreads scraper to link to for a different entity type on this platform, and no separate Goodreads review-text scraper in the catalog today. The one adjacent pairing that exists:

Scraper Name	What it extracts
Amazon Product Details & Variant ASINs Scraper	Amazon product pages by ASIN — pairs with the asin this Actor already returns for cross-market pricing and availability checks on the same edition

How to integrate Goodreads Book Scraper With Full Book Details with your stack

Goodreads Book Scraper With Full Book Details works with any language or tool that can make an HTTP request to the Apify API. The examples below use the official apify-client SDKs.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_TOKEN>")
ACTOR_ID = "<your-username>/goodreads-book-scraper-with-full-book-details"

run_input = {
    "bookSearchTerms": ["python programming", "cozy mystery"],
    "booksPerSearch": 20,
    "fetchFullBookDetails": True,
    "includeSimilarBooks": False,
}

run = client.actor(ACTOR_ID).call(run_input=run_input)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("goodreads_books.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print(f"Saved {len(rows)} rows to goodreads_books.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const ACTOR_ID = '<your-username>/goodreads-book-scraper-with-full-book-details';

const run = await client.actor(ACTOR_ID).call({
    bookSearchTerms: ['python programming', 'cozy mystery'],
    booksPerSearch: 20,
    fetchFullBookDetails: true,
    includeSimilarBooks: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} rows`);
console.log(items[0]);

Async and scheduled pipelines

For large multi-search jobs, start the run and poll client.run(runId).get() for its status instead of blocking on .call(), or use client.actor(ACTOR_ID).start() and pick up the dataset once the run status is SUCCEEDED. For recurring collection, an Apify schedule re-runs the same input on the interval you set, and each run's dataset can be read back through the same apify_client calls above.

🎯 Who Needs Goodreads Book Scraper With Full Book Details? (Use Cases & Industries)

🏢 Publishers and booksellers

A backlist or catalog team runs a batch of ISBNs through bookSearchTerms and reconciles isbn13, format, numPages and publicationDate against their own inventory records, flagging editions that don't match.

📊 AI and RAG teams

An engineering team indexes description, title, author and genres into a vector store so a reading-assistant agent can answer "books like this one" questions with metadata pulled the same day, not a stale prior baked into a model.

📱 Market and competitive analysts

An analyst tracks ratingValue, ratingsCountValue and editionsCount for a shelf of titles on a schedule, watching for the ratings-count jumps and new-edition signals that indicate a title is picking up momentum.

🔬 Researchers

A literature or publishing researcher builds a dataset from genre or author search terms and works with genres, seriesName, ratingValue and publishedYear for analysis — all data Goodreads already shows to any visitor.

🎥 Product and SaaS builders

A reading-recommendation or personal-library app builds its recommendation graph on similarBook rows and its catalog display on the full edition record, instead of maintaining an in-house Goodreads parser.

Is it legal to scrape Goodreads?

Scraping publicly accessible web pages is generally lawful in the United States; courts have repeatedly declined to treat access to data a website makes available to any visitor as unauthorized access under the Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 9th Circuit, 2019). That question is separate from Goodreads' own Terms of Service, which may restrict automated access — a ToS violation is a contract matter between the user and Goodreads, not a criminal one, but it's a real business risk worth reading before running large or commercial jobs. Goodreads Book Scraper With Full Book Details returns book, edition and series catalog data rather than data about private individuals, so this falls under business/catalog-data and terms-of-service considerations rather than GDPR or CCPA personal-data obligations; author biography fields are content the author or publisher has already published on their own public Goodreads page. Goodreads Book Scraper With Full Book Details returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications.

❓ Frequently asked questions

Does Goodreads Book Scraper With Full Book Details work without a Goodreads account?

Yes. It reads only publicly visible search results and book pages and never logs in — no Goodreads account, password or API key is needed to run it.

How does Goodreads Book Scraper With Full Book Details handle Goodreads' anti-scraping measures?

Each search session opens on Goodreads' home page first to establish cookies, since a cold first request for a result page is answered with an interstitial rather than the real listing. Result pages are checked for genuine listing content before being accepted, retried up to five times with a short backoff on retryable HTTP statuses (202, 403, 408, 429, 500, 502, 503, 504), and a session that stops being served is replaced with a fresh one. ⚠️ Runs start without a proxy for speed; if plain requests stop being served, the Actor automatically switches the rest of that run to a RESIDENTIAL-group Apify Proxy fallback, even if proxyConfiguration was left off in the input.

Can I run Goodreads Book Scraper With Full Book Details at scale without getting blocked?

There's no published uptime or success-rate guarantee. What is documented in the source: each search is capped at 500 result pages as an internal safety limit regardless of booksPerSearch, and requestDelayMs (up to 60000 ms) lets you pace requests more gently across a large multi-search run.

How fresh is the data Goodreads Book Scraper With Full Book Details returns?

Every run fetches search results and book records live from Goodreads at run time — nothing is served from a cache. scrapedAt on each row records exactly when that row was collected.

Which Goodreads fields work best for AI training and RAG indexing?

For RAG, description and authorBio are the high-information free-text fields worth embedding. For training data, isbn13, format, language, genres and seriesPosition are the fields with the most consistent structure across records, since they come from Goodreads' own edition record rather than being parsed from rendered HTML. All fields return as typed primitives — strings, numbers, booleans or arrays — requiring no normalization before use.

What happens if a book's full details can't be loaded?

The book row is still saved with its search-listing fields (title, author, rating, url, and so on) intact; detailsStatus is set to unavailable and the edition/author fields come back null for that row rather than blocking the run.

Can I search by ISBN instead of a title?

Yes. Goodreads' own search box accepts an ISBN the same way it accepts a title or author name, and the Actor passes each line in bookSearchTerms straight into that search — every result row also returns isbn and isbn13 for its edition.

Will my existing urls / resultsPerQuery input JSON still work?

Yes. Those are the original keys from the plain Goodreads book scraper this Actor extends. They're read automatically whenever bookSearchTerms / booksPerSearch are left empty, so older input JSON keeps running unchanged.

Does Goodreads Book Scraper With Full Book Details work with Claude, ChatGPT and other AI agent tools?

It's callable as an HTTP endpoint by any agent framework through the Apify API — there's no dedicated MCP server for this Actor. Every response is typed JSON, so an agent can consume a row directly without parsing HTML first.

Are similar-book rows charged the same as book rows?

Yes. Every row pushed to the dataset — book or similarBook — is charged as one row_result event, including rows where detailsStatus is unavailable. There are no free or uncharged accounting rows in this Actor; maxBooksTotal and maxSimilarBooksPerBook are the two inputs that directly control row count.

ℹ️ Disclaimer

Goodreads Book Scraper With Full Book Details extracts only publicly available data from Goodreads. This tool is intended for lawful use cases only. Users are responsible for complying with Goodreads' terms of service and applicable data protection laws in their jurisdiction.