# Goodreads Book & Reviews Scraper (`devilscrapes/goodreads-book-reviews-scraper`) Actor

Extract Goodreads book metadata, ratings, and reader reviews from book URLs, author or list pages, or free-text/ISBN search. One Pay-Per-Event Actor covers book details, ratings, and embedded reviews — no login, no API key, no separate subscription.

- **URL**: https://apify.com/devilscrapes/goodreads-book-reviews-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Goodreads Book & Reviews Scraper

**💰 $2.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Extract Goodreads book metadata, ratings, and reader reviews from book URLs, author or list pages, or free-text/ISBN search. One Pay-Per-Event Actor covers book details, ratings, and embedded reviews — no login, no API key, no separate subscription.

</div>

---

### 🎯 What this scrapes

Goodreads retired its official API in December 2020, leaving no supported way to pull book metadata, ratings, or review text at scale. This Actor resolves books three ways — direct book, author, or list/shelf (Listopia) URLs, free-text or ISBN search, or a shelf page you already have bookmarked — and returns full book metadata (title, author, series, genres, ISBNs, ratings, awards) plus the reviews Goodreads embeds on the page, in one PPE-priced call.

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Chrome / Firefox / Safari TLS handshakes so Goodreads sees a browser, not Python.
- 🌐 **Apify Proxy on every request**, escalating to residential exit IPs with no input change if a block ever shows up.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 503` — up to 5 attempts per page, `Retry-After` honoured.
- 🧱 **Session rotation on every block** — a fresh proxy session and browser fingerprint the moment one gets flagged.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable book IDs, JSON / CSV / Excel export straight from the Apify Console.
- 💰 **Pay-Per-Event pricing** — you only pay for book and review rows that hit your dataset. No data, no charge.

### 💡 Use cases

- **Catalogue enrichment** — backfill title, author, series, ISBN, and cover-image metadata for a bookstore, library, or reading-app catalogue.
- **Reader-sentiment research** — pull a book's rating distribution and a sample of review text to gauge audience reception before an author/publisher marketing push.
- **"Best of" dataset building** — resolve every book on a Listopia list or shelf page into one structured dataset for recommendation or curation tools.
- **Rating/review monitoring** — re-run against the same book URLs on a schedule to track how average rating and ratings count move over time.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Add one or more **Start URLs** (book, author, or list/shelf pages) and/or **Search queries** (titles, authors, or ISBNs) — at least one of the two is required.
3. Turn on **Include reviews** if you want reader reviews attached, and pick **Output mode** (`books` or `reviews`).
4. Click **Start**. Output streams into the run's dataset.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `startUrls` | `array` | no\* | `[]` | Direct book (`/book/show/...`), author (`/author/show/...`), or list/shelf (`/list/show/...`, `/author/list/...`) URLs. |
| `searchQueries` | `array` | no\* | `[]` | Free-text titles/authors or ISBN-10/13, resolved via Goodreads' auto-complete search. |
| `maxBooks` | `integer` | no | `20` | Cap on total distinct books resolved, across every Start URL and Search query combined (1-500). |
| `maxSearchResultsPerQuery` | `integer` | no | `3` | Auto-complete hits expanded into a book fetch, per Search queries entry (1-20). |
| `includeReviews` | `boolean` | no | `false` | Attach the reviews Goodreads embeds on each book page. |
| `maxReviewsPerBook` | `integer` | no | `10` | Cap on reviews attached per book (1-30) — Goodreads embeds ~20-30 for anonymous visitors. |
| `outputMode` | `string` | no | `"books"` | `books`: one row per book, reviews nested. `reviews`: one row per review (requires `includeReviews: true`). |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Standard Apify Proxy block — escalate to `RESIDENTIAL` if you ever see a block. |

\* At least one of `startUrls` / `searchQueries` must be non-empty.

#### Example input

```json
{
  "startUrls": ["https://www.goodreads.com/book/show/2767052-the-hunger-games"],
  "searchQueries": [],
  "maxBooks": 1,
  "maxSearchResultsPerQuery": 3,
  "includeReviews": true,
  "maxReviewsPerBook": 2,
  "outputMode": "books",
  "proxyConfiguration": {"useApifyProxy": true}
}
````

### 📤 Output

Every row is one dataset item. `books` mode (the default) emits one row per resolved book, with reviews nested inside; `reviews` mode flattens the same data into one row per individual review.

| Field | Type | Notes |
|---|---|---|
| `book_id` | `string` | Goodreads numeric book ID. |
| `work_id` | `string \| null` | Goodreads work ID. |
| `title` / `title_complete` | `string` | Title, and title with series suffix. |
| `url` | `string` | Canonical book page URL. |
| `author_name` / `author_url` | `string \| null` | Primary author. |
| `series_name` / `series_position` | `string \| null` | Series title and position within it. |
| `genres` | `array` | Genre tags. |
| `format` / `num_pages` / `publisher` / `isbn` / `isbn13` / `asin` / `language` | mixed | Edition metadata. |
| `publish_date` / `original_publish_date` | `string \| null` | ISO dates for this edition / the original work. |
| `description` | `string \| null` | Book blurb, HTML stripped. |
| `image_url` | `string \| null` | Cover image URL. |
| `average_rating` / `ratings_count` / `text_reviews_count` | number/int `\| null` | Work-level rating stats. |
| `ratings_count_distribution` | `array` | Rating histogram, index 0 = 1★ … index 4 = 5★. |
| `awards` | `array` | Awards won. |
| `reviews` | `array` | Embedded reviews (books mode) — populated only when `includeReviews: true`. |
| `reviews_returned_count` | `integer` | How many reviews were actually attached. |
| `source_query` | `string \| null` | The Start URL or Search queries entry that resolved this book. |
| `scraped_at` | `string` | ISO 8601 UTC timestamp when the row was fetched. |

#### Example output

```json
{
  "book_id": "2767052",
  "work_id": "2792775",
  "title": "The Hunger Games",
  "title_complete": "The Hunger Games (The Hunger Games, #1)",
  "url": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
  "author_name": "Suzanne Collins",
  "author_url": "https://www.goodreads.com/author/show/153394.Suzanne_Collins",
  "series_name": "The Hunger Games",
  "series_position": "1",
  "genres": ["Young Adult", "Dystopia", "Fiction", "Science Fiction"],
  "format": "Hardcover",
  "num_pages": 374,
  "publisher": "Scholastic Press",
  "isbn": "0439023483",
  "isbn13": "9780439023481",
  "asin": null,
  "language": "English",
  "publish_date": "2008-10-14",
  "original_publish_date": "2008-09-14",
  "description": "Winning means fame and fortune. Losing means certain death. The Hunger Games have begun...",
  "image_url": "https://m.media-amazon.com/images/S/compressed.photo.goodreads.com/books/1586722975i/2767052.jpg",
  "average_rating": 4.35,
  "ratings_count": 10190318,
  "ratings_count_distribution": [133754, 242196, 1113954, 3090721, 5609693],
  "text_reviews_count": 273383,
  "awards": ["Georgia Peach Book Award (WINNER)", "Buxtehuder Bulle (WINNER)"],
  "reviews": [
    {
      "review_id": "kca://review:goodreads/amzn1.gr.review:goodreads.v1.-GjjHy9iBCConbkcwszIsw",
      "reviewer_name": "Jayson",
      "reviewer_url": "https://www.goodreads.com/user/show/22106879-jayson",
      "reviewer_followers_count": 4318,
      "rating": 4,
      "review_text": "(A-) 83% | Very Good. Notes: A Pax Romana parallel, where odds are ever mostly misses...",
      "like_count": 693,
      "comment_count": 68,
      "has_spoiler": false,
      "created_at": "2020-09-18T02:33:35Z",
      "updated_at": "2026-05-22T05:01:56Z"
    }
  ],
  "reviews_returned_count": 1,
  "source_query": "https://www.goodreads.com/book/show/2767052-the-hunger-games",
  "scraped_at": "2026-07-20T00:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `apify-actor-start` | $0.01 | One-off warm-up charge per run |
| `apify-default-dataset-item` | $0.002 | Per book or review row written to the dataset — **$2.00 / 1 000 results** |

No subscription, no minimum, no card required to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

Reviews are capped at what Goodreads server-embeds for anonymous visitors — observed ~20-30 per book, further capped by `maxReviewsPerBook` (max 30). Full review-corpus pagination beyond that page requires a logged-in session and is out of scope. Authenticated actions (shelving, following, posting reviews), quotes/Q\&A/giveaways, and non-English or localized Goodreads domains are also out of scope for v1.

### ❓ FAQ

**Do I need a Goodreads account or API key?**

No. Goodreads retired its official API in December 2020; this Actor reads the same public book, author, and list pages a signed-out visitor sees — no login, no key.

**How many reviews can I get per book?**

Up to the ~20-30 reviews Goodreads server-embeds on the book page for anonymous visitors, capped further by `maxReviewsPerBook`. The full review corpus beyond that page requires a logged-in session and is out of scope.

**What's the difference between `books` and `reviews` output mode?**

`books` mode emits one row per book with its reviews nested inside. `reviews` mode flattens the same data into one row per individual review — turn on `includeReviews` for either mode to actually fetch review content.

**Can I search by ISBN instead of title?**

Yes — `searchQueries` accepts ISBN-10 or ISBN-13 codes as well as free-text titles/authors; both resolve through Goodreads' own auto-complete search.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new field? Open an issue on the Actor's **Issues** tab on Apify Console — we ship fixes weekly and we read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `startUrls` (type: `array`):

Direct Goodreads URLs — a book page (/book/show/...), an author page (/author/show/...), or a list/shelf page (/list/show/... or /author/list/...). One of Start URLs / Search queries is required.

## `searchQueries` (type: `array`):

Free-text book/author titles or ISBN-10/13 codes, resolved via Goodreads' auto-complete search. One of Start URLs / Search queries is required.

## `maxBooks` (type: `integer`):

Cap on the total number of distinct books resolved and fetched across every Start URL and Search query combined.

## `maxSearchResultsPerQuery` (type: `integer`):

How many auto-complete hits to expand into a book fetch for each Search queries entry.

## `includeReviews` (type: `boolean`):

Attach the reviews Goodreads embeds on each book page (up to ~20-30 for anonymous visitors) to every resolved book row.

## `maxReviewsPerBook` (type: `integer`):

Cap on reviews attached per book when Include reviews is on. Goodreads server-embeds roughly 20-30 reviews per book for anonymous visitors — more requires a logged-in session and is out of scope.

## `outputMode` (type: `string`):

'Books' emits one row per resolved book with reviews nested inside. 'Reviews' emits one row per individual review and requires Include reviews to be on.

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

Apify Proxy routes every request. Plain Apify Proxy is enough today — escalate to the RESIDENTIAL group here with no code change if Goodreads ever adds a block.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.goodreads.com/book/show/2767052-the-hunger-games"
  ],
  "searchQueries": [],
  "maxBooks": 20,
  "maxSearchResultsPerQuery": 3,
  "includeReviews": false,
  "maxReviewsPerBook": 10,
  "outputMode": "books",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "startUrls": [
        "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("devilscrapes/goodreads-book-reviews-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 = {
    "startUrls": ["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("devilscrapes/goodreads-book-reviews-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 '{
  "startUrls": [
    "https://www.goodreads.com/book/show/2767052-the-hunger-games"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/goodreads-book-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goodreads Book & Reviews Scraper",
        "description": "Extract Goodreads book metadata, ratings, and reader reviews from book URLs, author or list pages, or free-text/ISBN search. One Pay-Per-Event Actor covers book details, ratings, and embedded reviews — no login, no API key, no separate subscription.",
        "version": "0.0",
        "x-build-id": "lWw9rZnXvrHWlmHSs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~goodreads-book-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-goodreads-book-reviews-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/devilscrapes~goodreads-book-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-goodreads-book-reviews-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/devilscrapes~goodreads-book-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-goodreads-book-reviews-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Goodreads URLs — a book page (/book/show/...), an author page (/author/show/...), or a list/shelf page (/list/show/... or /author/list/...). One of Start URLs / Search queries is required.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text book/author titles or ISBN-10/13 codes, resolved via Goodreads' auto-complete search. One of Start URLs / Search queries is required.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBooks": {
                        "title": "Max books",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on the total number of distinct books resolved and fetched across every Start URL and Search query combined.",
                        "default": 20
                    },
                    "maxSearchResultsPerQuery": {
                        "title": "Max search results per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many auto-complete hits to expand into a book fetch for each Search queries entry.",
                        "default": 3
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Attach the reviews Goodreads embeds on each book page (up to ~20-30 for anonymous visitors) to every resolved book row.",
                        "default": false
                    },
                    "maxReviewsPerBook": {
                        "title": "Max reviews per book",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Cap on reviews attached per book when Include reviews is on. Goodreads server-embeds roughly 20-30 reviews per book for anonymous visitors — more requires a logged-in session and is out of scope.",
                        "default": 10
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "books",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "'Books' emits one row per resolved book with reviews nested inside. 'Reviews' emits one row per individual review and requires Include reviews to be on.",
                        "default": "books"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy routes every request. Plain Apify Proxy is enough today — escalate to the RESIDENTIAL group here with no code change if Goodreads ever adds a block.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```