# Goodreads Review Scraper (`scrapier/goodreads-review-scraper`) Actor

📚 Goodreads Review Scraper extracts book reviews at scale — ratings, review text, dates, reviewer profiles, helpful votes & shelves. 🔎 Clean, structured data for sentiment analysis & insights. 🚀 Perfect for authors, publishers, marketers & researchers.

- **URL**: https://apify.com/scrapier/goodreads-review-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Review Scraper

The Goodreads Review Scraper is a production-ready Apify actor that extracts public Goodreads book reviews at scale — including star ratings, full review text, timestamps, reviewer profiles, helpful votes, and shelving metadata. It solves the manual copy‑paste problem by programmatically calling Goodreads’ getReviews GraphQL endpoint and streaming clean, structured rows into your dataset as they’re found. Built for marketers, developers, data analysts, authors, publishers, and researchers, this Goodreads review extractor helps you scrape Goodreads reviews and export them for sentiment analysis, audience insights, and market research at scale. 🚀

### What data / output can you get?

Below are the exact fields pushed to your dataset for each review. These match the flattened shape returned by Goodreads’ getReviews API.

| Data type | Description | Example value |
| --- | --- | --- |
| bookUrl | Source book URL for the review | https://www.goodreads.com/book/show/26032825 |
| id | Review ID from Goodreads | "123456789" |
| rating | Star rating given by the reviewer | 5 |
| text | Full review text | "A brilliant sequel with unforgettable characters..." |
| createdAt | Review creation timestamp (ms) | 1714147200000 |
| updatedAt | Review last update timestamp (ms) | 1714752000000 |
| lastRevisionAt | Last revision timestamp (ms) | 1714838400000 |
| recommendFor | Audience recommendation text if present | null |
| spoilerStatus | Spoiler setting for the review | "NONE" |
| likeCount | Number of likes/helpful votes | 12 |
| commentCount | Number of comments on the review | 3 |
| viewerHasLiked | Whether the current viewer liked it (from API) | false |
| shelving | Shelving metadata: shelf, tags, URLs | {"shelf":{"name":"read","webUrl":"https://www.goodreads.com/review/list/...","__typename":"Shelf"},"taggings":[{"tag":{"name":"fantasy","webUrl":"https://www.goodreads.com/genres/fantasy","__typename":"Tag"},"__typename":"Tagging"}],"webUrl":"https://www.goodreads.com/review/list/...","__typename":"Shelving"} |
| creator | Reviewer profile object (id, name, links, counts) | {"id":"987654","name":"Jane Doe","webUrl":"https://www.goodreads.com/user/show/987654-jane-doe","imageUrlSquare":"https://images.gr-assets.com/...","isAuthor":false,"followersCount":245,"textReviewsCount":102,"viewerRelationshipStatus":{"isBlockedByViewer":false,"__typename":"ViewerRelationshipStatus"},"contributor":{"id":"123","works":{"totalCount":2,"__typename":"WorksConnection"},"__typename":"Contributor"},"__typename":"User"} |
| __typename | GraphQL typename for the review node | "Review" |

Notes:
- Fields like creator and shelving can be null if not provided in the response.
- You can download your Goodreads reviews dataset from Apify in JSON, CSV, or Excel formats for further analysis.

### Key features

- ⚡️ Bold-scale extraction with clean output  
  Streams one row per review directly into your Apify dataset as they’re scraped — perfect for building a Goodreads reviews dataset and powering Goodreads review data extraction workflows.

- 🧩 Flexible filters & sorting  
  Choose sortBy (popular, newest, oldest), languageCode (e.g., en or all), and reviewEdition (ALL vs only_this_book) to tailor your Goodreads review mining to specific audiences.

- 📚 Work-wide vs edition-only scope  
  Switch between all editions for the work (ALL) and only this specific edition (only_this_book) to match your analysis needs in your Goodreads book reviews scraper workflows.

- 🌍 Language filtering  
  Filter reviews by language using languageCode, with options like en, fr, de, es, it, and more. Ideal for multilingual analysis and to scrape Goodreads book ratings by locale.

- 🛡️ Resilient connection strategy  
  Smart proxy escalation: starts direct, then Apify datacenter, then RESIDENTIAL (locked for the rest of the run) with retries and backoff. Built for reliability in your Goodreads review crawler.

- 🔗 Bulk input support  
  Paste full Goodreads book URLs or just the numeric ID (e.g., 26032825) — the actor will normalize them for you. Great for batch jobs that download Goodreads reviews at scale.

- 📋 Real-time streaming to Output  
  Live rows appear in your Output table as each review is saved, making it a responsive Goodreads reviews exporter for monitoring and quality checks.

- 🐍 Python-powered, developer-friendly  
  Implemented in Python with Apify SDK — easy to integrate into pipelines or consume via the Apify dataset API in your Goodreads review scraper Python workflows.

### How to use Goodreads Review Scraper - step by step

1. Create or log in to your Apify account.  
2. Open the Goodreads Review Scraper actor on Apify.  
3. In the Input, add your book identifiers under urls. You can paste full Goodreads URLs like https://www.goodreads.com/book/show/26032825 or just the numeric ID 26032825.  
4. Set maxItems to control how many reviews to collect per book.  
5. (Optional) Expand Filters & sorting and configure:  
   - sortBy: popular, newest, or oldest  
   - languageCode: a specific language like en, fr, de, etc., or all for no filter  
   - reviewEdition: ALL for all editions, or only_this_book for the current edition  
6. (Optional) Configure proxyConfiguration if you need custom proxy settings; the actor will automatically escalate connection strategy if needed.  
7. Click Start to run. You’ll see status updates as reviews are discovered and saved.  
8. Download results from the dataset in JSON, CSV, or Excel to feed analytics, dashboards, or research.

Pro Tip: Combine filtered runs (e.g., languageCode=en, sortBy=newest) with automation to keep a fresh Goodreads reviews dataset for sentiment tracking.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing analytics + sentiment | Analyze reviewer text and ratings to quantify sentiment and identify messaging opportunities from public Goodreads opinions. |
| Author/publisher feedback loop | Track newest reviews per title to inform blurbs, covers, and positioning with real reader reactions. |
| Academic research (literature) | Study reading trends by language, shelving tags, and rating distributions across genres and regions. |
| Product strategy (editions) | Compare ALL vs only_this_book to see edition-level differences and edition-specific feedback. |
| Data enrichment for dashboards | Feed structured rating, likeCount, and commentCount data into BI tools for trend tracking. |
| Developer pipelines (API) | Use the Apify dataset API to integrate the Goodreads reviews exporter into ETL workflows. |
| Market trend analysis | Group by shelving tags and reviewer profiles to uncover sub-genre clusters and audience niches. |

### Why choose Goodreads Review Scraper?

This Goodreads review scraping tool is built for precision, automation, and reliability.

- ✅ Accurate, structured fields that mirror Goodreads’ getReviews GraphQL shape.
- 🌍 Multilingual filtering using languageCode for targeted datasets.
- 📦 Scales to multiple books with bulk urls input and per‑book limits via maxItems.
- 🐍 Developer-friendly foundation in Python and Apify, easy to integrate into pipelines.
- 🛡️ Ethical by design: collects only public reviews and respects platform constraints.
- 💰 Cost-effective automation for ongoing Goodreads review data extraction.
- 🔌 Integration-ready outputs for CSV/JSON/Excel exports and downstream analytics.
- 🧭 More reliable than browser extensions or manual scripts thanks to smart proxy escalation and retries.

In short, it’s a robust Goodreads ratings scraper and Goodreads user reviews scraper that fits modern data workflows without the instability of one-off tools.

### Is it legal / ethical to use Goodreads Review Scraper?

Yes — when used responsibly. This actor collects only publicly visible reviews and does not access private or authenticated data. You are responsible for respecting Goodreads’ terms and applicable laws.

Guidelines for compliant use:
- Collect only public content and avoid private or authenticated areas of the site.
- Be mindful of GDPR, CCPA, and relevant data protection regulations in your region.
- Use scraped data responsibly and for legitimate research, analytics, or reporting use cases.
- Consult your legal team for edge cases or redistribution policies.

### Input parameters & output format

#### Example JSON input
```json
{
  "urls": [
    "https://www.goodreads.com/book/show/26032825",
    "26032825"
  ],
  "maxItems": 50,
  "filtersAndOptions": {
    "sortBy": "oldest",
    "languageCode": "en",
    "reviewEdition": "only_this_book"
  },
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| urls | array | Yes | — | Paste one or more Goodreads book links. Tip: you can paste just the number from the URL (e.g., 26032825) — the actor will fix the link for you. |
| maxItems | integer | No | 20 | How many reviews to collect for each book in your list. |
| filtersAndOptions.sortBy | string | No | "popular" | Sort reviews by: popular, newest, or oldest. |
| filtersAndOptions.languageCode | string | No | "all" | All languages (no filter) or choose one language; reviews are filtered to match (e.g., en, fr, de, es, it, pt, ru, ja, ko, zh, ar, hi, nl, pl, tr, vi, id, th). |
| filtersAndOptions.reviewEdition | string | No | "ALL" | ALL (reviews for the whole work) or only\_this\_book (this edition only). |
| proxyConfiguration | object | No | — | Optional Apify Proxy settings. If something blocks a run, the actor can switch routing automatically. |

Note: The actor also supports legacy top-level keys sortBy, languageCode, and reviewEdition; if both are provided, filtersAndOptions takes precedence.

#### Example JSON output

```json
[
  {
    "bookUrl": "https://www.goodreads.com/book/show/26032825",
    "__typename": "Review",
    "id": "123456789",
    "creator": {
      "id": "987654",
      "imageUrlSquare": "https://images.gr-assets.com/...",
      "isAuthor": false,
      "viewerRelationshipStatus": {
        "isBlockedByViewer": false,
        "__typename": "ViewerRelationshipStatus"
      },
      "followersCount": 245,
      "__typename": "User",
      "textReviewsCount": 102,
      "name": "Jane Doe",
      "webUrl": "https://www.goodreads.com/user/show/987654-jane-doe",
      "contributor": {
        "id": "123",
        "works": {
          "totalCount": 2,
          "__typename": "WorksConnection"
        },
        "__typename": "Contributor"
      }
    },
    "recommendFor": null,
    "updatedAt": 1714752000000,
    "createdAt": 1714147200000,
    "spoilerStatus": "NONE",
    "lastRevisionAt": 1714838400000,
    "text": "A brilliant sequel with unforgettable characters and pacing.",
    "rating": 5,
    "shelving": {
      "shelf": {
        "name": "read",
        "webUrl": "https://www.goodreads.com/review/list/...",
        "__typename": "Shelf"
      },
      "taggings": [
        {
          "tag": {
            "name": "fantasy",
            "webUrl": "https://www.goodreads.com/genres/fantasy",
            "__typename": "Tag"
          },
          "__typename": "Tagging"
        }
      ],
      "webUrl": "https://www.goodreads.com/review/list/...",
      "__typename": "Shelving"
    },
    "likeCount": 12,
    "viewerHasLiked": false,
    "commentCount": 3
  }
]
```

Notes:

- creator and shelving may be null if not present in the response.
- Timestamps are returned as integers in milliseconds.

### FAQ

#### Do I need to log in to scrape Goodreads reviews?

No. The actor collects only public reviews and does not require login or cookies. It works as a Goodreads review scraping tool for publicly available content.

#### Can I input just the Goodreads numeric ID instead of a full URL?

Yes. You can paste a numeric ID like 26032825 into urls and the actor will convert it to a valid Goodreads book URL automatically.

#### How many reviews can I scrape per book?

You control this with maxItems. By default it is 20 per book (from the input schema), and you can set higher limits up to 10,000 per book.

#### Can I filter reviews by language?

Yes. Use filtersAndOptions.languageCode. Set it to a specific code like en, fr, de, es, it, etc., or use all for no filter to build multilingual Goodreads reviews datasets.

#### Can I choose between all editions and just this specific edition?

Yes. Set filtersAndOptions.reviewEdition to ALL for the entire work or only\_this\_book to limit to the specific edition — ideal for precise Goodreads review mining.

#### How are results exported?

All rows are saved to your Apify dataset in real time. You can download results in JSON, CSV, or Excel from the dataset, making this a handy Goodreads reviews exporter for analytics.

#### Is this a Goodreads review scraper Python solution?

Yes. The actor is implemented in Python and runs on Apify’s infrastructure. You can integrate the dataset outputs into your own Python pipelines or consume them via the Apify API.

#### Is this a Goodreads review scraper Chrome extension?

No extension is required. This is a cloud-based Goodreads review crawler that runs reliably on Apify, with smart proxy escalation built in.

#### Is it legal to use this scraper?

Yes, when used responsibly. The actor gathers only publicly available data. You are responsible for complying with Goodreads’ terms and relevant laws.

### Closing thoughts

Goodreads Review Scraper is built to extract structured, reliable Goodreads review data at scale. With bulk input, flexible filters, and robust connectivity, it empowers marketers, developers, researchers, authors, and publishers to export clean Goodreads review datasets for analytics and insights. Developers can automate workflows using Apify datasets and standard exports, while analysts benefit from ready-to-use JSON/CSV/Excel outputs. Start extracting smarter Goodreads book insights today and turn public reviews into actionable intelligence.

### What are other Good scraping tools?

If you want to scrape specific Good data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Goodreads Book Search](https://apify.com/scrapier/goodreads-book-search) | [Goodreads Phone Number Scraper](https://apify.com/scrapier/goodreads-phone-number-scraper) |
| [Goodreads Email Scraper](https://apify.com/scrapier/goodreads-email-scraper) |  |

# Actor input Schema

## `urls` (type: `array`):

Paste one or more Goodreads book links. **Tip:** you can paste just the number from the URL (e.g. `26032825`) — we’ll fix the link for you. 🌟

## `maxItems` (type: `integer`):

How many reviews to collect **for each** book in your list. (Example: 50 here × 3 books = up to 150 rows.) 📊

## `filtersAndOptions` (type: `object`):

🎛️ **Optional:** open this section to change sort order, language, and which edition reviews come from. Leave defaults for a quick start! 👇

## `proxyConfiguration` (type: `object`):

🌐 **Optional.** Turn on Apify Proxy if you need extra reliability. If something blocks a run, we’ll try smarter routing automatically — you stay focused on the results. ✨

## Actor input object example

```json
{
  "urls": [
    "https://www.goodreads.com/book/show/26032825"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.goodreads.com/book/show/26032825"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/goodreads-review-scraper").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 = {
    "urls": ["https://www.goodreads.com/book/show/26032825"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/goodreads-review-scraper").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 '{
  "urls": [
    "https://www.goodreads.com/book/show/26032825"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/goodreads-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapier/goodreads-review-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goodreads Review Scraper",
        "description": "📚 Goodreads Review Scraper extracts book reviews at scale — ratings, review text, dates, reviewer profiles, helpful votes & shelves. 🔎 Clean, structured data for sentiment analysis & insights. 🚀 Perfect for authors, publishers, marketers & researchers.",
        "version": "1.0",
        "x-build-id": "9gzkSid9KjiO2fCG0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~goodreads-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-goodreads-review-scraper",
                "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/scrapier~goodreads-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-goodreads-review-scraper",
                "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/scrapier~goodreads-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-goodreads-review-scraper",
                "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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "📚 Book URLs",
                        "type": "array",
                        "description": "Paste one or more Goodreads book links. **Tip:** you can paste just the number from the URL (e.g. `26032825`) — we’ll fix the link for you. 🌟",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "🔢 Max reviews per book",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many reviews to collect **for each** book in your list. (Example: 50 here × 3 books = up to 150 rows.) 📊",
                        "default": 20
                    },
                    "filtersAndOptions": {
                        "title": "⚙️ Filters & sorting",
                        "type": "object",
                        "description": "🎛️ **Optional:** open this section to change sort order, language, and which edition reviews come from. Leave defaults for a quick start! 👇",
                        "properties": {
                            "sortBy": {
                                "title": "📊 Sort reviews by",
                                "type": "string",
                                "description": "⭐ **Popular** — most helpful first · 🆕 **Newest** — newest first · 📜 **Oldest** — oldest first",
                                "editor": "select",
                                "enum": [
                                    "popular",
                                    "newest",
                                    "oldest"
                                ],
                                "default": "popular"
                            },
                            "languageCode": {
                                "title": "🌍 Review language",
                                "type": "string",
                                "description": "🌐 **All languages** — no filter · Or choose one language — reviews are filtered to match. 🗣️",
                                "editor": "select",
                                "enum": [
                                    "all",
                                    "en",
                                    "bn",
                                    "fr",
                                    "de",
                                    "es",
                                    "it",
                                    "pt",
                                    "ru",
                                    "ja",
                                    "ko",
                                    "zh",
                                    "ar",
                                    "hi",
                                    "nl",
                                    "pl",
                                    "tr",
                                    "vi",
                                    "id",
                                    "th"
                                ],
                                "enumTitles": [
                                    "All languages",
                                    "English",
                                    "Bengali",
                                    "French",
                                    "German",
                                    "Spanish",
                                    "Italian",
                                    "Portuguese",
                                    "Russian",
                                    "Japanese",
                                    "Korean",
                                    "Chinese",
                                    "Arabic",
                                    "Hindi",
                                    "Dutch",
                                    "Polish",
                                    "Turkish",
                                    "Vietnamese",
                                    "Indonesian",
                                    "Thai"
                                ],
                                "default": "all"
                            },
                            "reviewEdition": {
                                "title": "📖 Edition scope",
                                "type": "string",
                                "description": "📚 **All editions** — reviews for the whole work · 📕 **This book only** — reviews for this edition. 🎯",
                                "editor": "select",
                                "enum": [
                                    "ALL",
                                    "only_this_book"
                                ],
                                "default": "ALL"
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (optional)",
                        "type": "object",
                        "description": "🌐 **Optional.** Turn on Apify Proxy if you need extra reliability. If something blocks a run, we’ll try smarter routing automatically — you stay focused on the results. ✨"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
