# Goodreads Reviews Scraper Cheap (`data_api/goodreads-reviews-scraper-cheap`) Actor
Goodreads review scraper that collects book reviews, star ratings, and reviewer profiles without login or authentication, giving authors and researchers clean data for sentiment analysis and competitive research.
- **URL**: https://apify.com/data\_api/goodreads-reviews-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.99 / 1,000 results
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
## Goodreads Reviews Scraper
Reader reviews on Goodreads hold a lot of signal, but the site gives you no easy way to pull them out. You can scroll a book page forever and still end up copy-pasting one review at a time into a spreadsheet. This scraper skips all of that. Paste a book link, say how many reviews you want, and get back a clean table: the review text, the star rating, who wrote it, how many likes it picked up, and which shelf they filed it under. Run it on one title or a whole stack of them, and export to JSON, CSV, or Excel.
### What you get
One row per review, with a steady shape every time. Fields that a reviewer left blank come back as `null` rather than disappearing, so your columns line up when you load the data into a sheet or database. Each row carries three kinds of data:
- **The review** — `critiqueId`, `critiqueUrl`, `critiqueHtml`, `critiqueText`, `starRating`, `postedAt`, `editedAt`, `revisedAt`, `hasSpoiler`, `likesTotal`, `commentsTotal`, `recommendedAudience`
- **The reader** — `readerId`, `readerName`, `readerProfileUrl`, `readerAvatarUrl`, `readerIsAuthor`, `readerFollowers`, `readerReviewsWritten`
- **Shelf and book** — `shelfSlug`, `shelfLabel`, `shelfPageUrl`, `shelfTags`, `bookWorkId`, `collectedAt`
### Quick start
1. Click **Try for free** and open the input form.
2. Paste a Goodreads book link into **Book page URL**, or drop several into **Book page URLs** for a batch.
3. Set **Reviews per book** to cap how many reviews each title returns.
4. Choose a proxy if you want one, then press **Start** and export to JSON, CSV, Excel, or XML when the run wraps up.
### Use cases
- **Sentiment work** — collect a few hundred reader reviews to train a classifier or run opinion mining on how people reacted to a book
- **Author and competitor reading** — see what readers actually wrote about your titles or the ones you're up against
- **Recommendation engines** — feed ratings, shelves, and tags into similarity scoring or recommendation logic
- **Genre and market research** — gauge how readers responded to recent releases in a category before you commit to one
- **Academic datasets** — assemble reader-review corpora for literary or sociological study
- **Acquisition calls** — read feedback on comparable books before greenlighting something similar
### Input
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `titleUrl` | string | No | A single Goodreads book page link. Best for one title at a time. Example `https://www.goodreads.com/book/show/2767052-the-hunger-games`. |
| `titleUrls` | array of strings | No | A list of Goodreads book page links, one per row, for batch runs. |
| `reviewsLimit` | integer | No | Reviews to collect per book. Hard ceiling of 1000. Default `50`. |
| `runTimeoutSeconds` | integer | No | Cap on the whole run, in seconds. Default `420`. |
| `requestTimeoutSeconds` | integer | No | Cap on each API call, in seconds. Default `45`. |
| `proxyConfiguration` | object | No | Proxies used for requests. Datacenter is the default; switch to Residential if Goodreads starts blocking. |
You can fill `titleUrl`, `titleUrls`, or both. Repeated links are dropped.
#### Example input
```json
{
"titleUrls": [
"https://www.goodreads.com/book/show/2767052-the-hunger-games",
"https://www.goodreads.com/book/show/4671.The_Great_Gatsby"
],
"reviewsLimit": 50,
"runTimeoutSeconds": 420,
"requestTimeoutSeconds": 45,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": ["DATACENTER"]
}
}
````
### Output
Every review becomes one row, and each field is always present — values a reviewer never filled in come back as `null`, so the dataset stays rectangular.
#### Example output
```json
{
"critiqueId": "kca://review:goodreads/amzn1.gr.review:goodreads.v1.tI_H8-8bJGQv1O4IIOpeTA",
"critiqueUrl": "https://www.goodreads.com/review/show/2280609898",
"critiqueHtml": "4.5 Stars!
Buddy read with the gang and it held up...",
"critiqueText": "4.5 Stars! Buddy read with the gang and it held up...",
"starRating": 5,
"postedAt": "2018-02-01T20:15:18+00:00",
"editedAt": "2021-02-19T16:45:57+00:00",
"revisedAt": "2018-03-20T18:24:36+00:00",
"hasSpoiler": false,
"likesTotal": 114,
"commentsTotal": 17,
"recommendedAudience": null,
"readerId": 44125660,
"readerName": "Beth",
"readerProfileUrl": "https://www.goodreads.com/user/show/44125660-beth",
"readerAvatarUrl": "https://i.gr-assets.com/images/S/compressed.photo.goodreads.com/users/sample.jpg",
"readerIsAuthor": false,
"readerFollowers": 627,
"readerReviewsWritten": 929,
"shelfSlug": "read",
"shelfLabel": "Read",
"shelfPageUrl": "https://www.goodreads.com/review/list/44125660?shelf=read",
"shelfTags": ["2018-reads", "audiobook", "book-series", "five-stars", "young-adult-fantasy"],
"bookWorkId": "kca://work/amzn1.gr.work.v1.TbpxJa2CwiSSz_9W2FruoA",
"collectedAt": "2026-06-29T10:30:00+00:00"
}
```
#### Output fields
| Field | Type | Description |
|-------|------|-------------|
| `critiqueId` | string | Goodreads' identifier for the review |
| `critiqueUrl` | string | Direct link to the review |
| `critiqueHtml` | string | Review body as raw HTML |
| `critiqueText` | string | Review body as plain text, tags removed |
| `starRating` | integer | Stars given, 1 to 5, or null if none |
| `postedAt` | string | When the review first went up |
| `editedAt` | string | When the review was last changed |
| `revisedAt` | string | When the review text was last edited |
| `hasSpoiler` | boolean | Whether the review is flagged as a spoiler |
| `likesTotal` | integer | Number of likes |
| `commentsTotal` | integer | Number of comments |
| `recommendedAudience` | string | Who the reader recommends the book for, when noted |
| `readerId` | integer | Reviewer's numeric Goodreads ID |
| `readerName` | string | Reviewer's display name |
| `readerProfileUrl` | string | Link to the reviewer's profile |
| `readerAvatarUrl` | string | Link to the reviewer's profile photo |
| `readerIsAuthor` | boolean | Whether the reviewer is a published author |
| `readerFollowers` | integer | How many followers the reviewer has |
| `readerReviewsWritten` | integer | Total reviews the reviewer has written |
| `shelfSlug` | string | Shelf machine name (for example `read`, `currently-reading`) |
| `shelfLabel` | string | Reader-facing shelf name (for example `Read`) |
| `shelfPageUrl` | string | Link to the reviewer's shelf |
| `shelfTags` | array | Custom shelf tags the reviewer added |
| `bookWorkId` | string | Internal Goodreads work ID for the book |
| `collectedAt` | string | When the actor captured this review |
### Tips for best results
- **Try a small run first.** Scrape 10 reviews from one book before you point it at a long list — most URL or format snags show up in the first batch.
- **Switch to Residential if you get blocked.** Datacenter clears most books; reach for residential when you see repeated 403s or rate limits.
- **Mind the 1000-per-book ceiling.** `reviewsLimit` tops out at 1000 for each title, so split very popular books across separate runs if you need more.
- **Raise `requestTimeoutSeconds` to ~60** when you run on residential proxies or hit slow responses.
- **Batch with `titleUrls`.** Stack several links and the actor reads them in order into one dataset, so a multi-book pull is a single run.
### How can I use Goodreads reviews data?
**How can I use the Goodreads Reviews Scraper to run sentiment analysis on a book?**
Paste the book's link, set `reviewsLimit` to a few hundred, and run it. You get `critiqueText` for clean review bodies plus `starRating` for a labelled signal — enough to train a sentiment model or chart how reader reactions skew positive or negative for that title.
**How can I export Goodreads reviews to CSV or Excel?**
Run the scraper on one or more book links, then use the export button when it finishes. Every review lands as a row with the same columns — review text, rating, reader, likes, shelf — so the JSON, CSV, or Excel file drops straight into a spreadsheet or BI tool.
**How can I pull reviews for several books at once for genre research?**
Drop a batch of book links into `titleUrls` and the actor walks them in order, writing all reviews into one dataset tagged with `bookWorkId`. Group by that field to compare how readers responded across a genre or a set of comparable titles.
**How can I collect Goodreads reviewer profiles alongside the reviews?**
Each row already carries reader fields — `readerName`, `readerProfileUrl`, `readerFollowers`, `readerReviewsWritten`, and `readerIsAuthor` — so you can see who is reviewing, weight opinions by reach, or build a list of active reviewers in a niche without a second scrape.
### Is it legal to scrape data?
Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.
However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.
You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).
### Support
Questions, feature requests, or a field you'd like added? Reach out at and we'll get back to you.
# Actor input Schema
## `titleUrl` (type: `string`):
One Goodreads book page link. Best when you only need a single title. Scraping a batch? Use the Book page URLs list below instead.
## `titleUrls` (type: `array`):
A set of Goodreads book page links, one per row. Each title is read up to your per-book review cap before the actor moves to the next one.
## `reviewsLimit` (type: `integer`):
How many reviews to gather for each book before stopping. The hard ceiling is 1000.
## `requestTimeoutSeconds` (type: `integer`):
How long to wait on a single API call, in seconds, before giving up on it.
## `proxyConfiguration` (type: `object`):
Pick the proxies to route requests through. Useful for sidestepping IP bans and rate caps. Datacenter is quickest; Residential is the hardest to flag.
## Actor input object example
```json
{
"titleUrl": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
"titleUrls": [
"https://www.goodreads.com/book/show/2767052-the-hunger-games",
"https://www.goodreads.com/book/show/4671.The_Great_Gatsby"
],
"reviewsLimit": 50,
"requestTimeoutSeconds": 45,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"titleUrl": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("data_api/goodreads-reviews-scraper-cheap").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"titleUrl": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("data_api/goodreads-reviews-scraper-cheap").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 '{
"titleUrl": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call data_api/goodreads-reviews-scraper-cheap --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=data_api/goodreads-reviews-scraper-cheap",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Goodreads Reviews Scraper Cheap",
"description": "Goodreads review scraper that collects book reviews, star ratings, and reviewer profiles without login or authentication, giving authors and researchers clean data for sentiment analysis and competitive research.",
"version": "0.0",
"x-build-id": "JaR2Rq5fbHzrksyB2"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/data_api~goodreads-reviews-scraper-cheap/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-data_api-goodreads-reviews-scraper-cheap",
"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/data_api~goodreads-reviews-scraper-cheap/runs": {
"post": {
"operationId": "runs-sync-data_api-goodreads-reviews-scraper-cheap",
"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/data_api~goodreads-reviews-scraper-cheap/run-sync": {
"post": {
"operationId": "run-sync-data_api-goodreads-reviews-scraper-cheap",
"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": {
"titleUrl": {
"title": "Book page URL",
"type": "string",
"description": "One Goodreads book page link. Best when you only need a single title. Scraping a batch? Use the Book page URLs list below instead."
},
"titleUrls": {
"title": "Book page URLs",
"type": "array",
"description": "A set of Goodreads book page links, one per row. Each title is read up to your per-book review cap before the actor moves to the next one.",
"items": {
"type": "string"
}
},
"reviewsLimit": {
"title": "Reviews per book",
"minimum": 1,
"maximum": 1000,
"type": "integer",
"description": "How many reviews to gather for each book before stopping. The hard ceiling is 1000.",
"default": 50
},
"requestTimeoutSeconds": {
"title": "Request timeout (seconds)",
"minimum": 5,
"maximum": 120,
"type": "integer",
"description": "How long to wait on a single API call, in seconds, before giving up on it.",
"default": 45
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Pick the proxies to route requests through. Useful for sidestepping IP bans and rate caps. Datacenter is quickest; Residential is the hardest to flag."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```