# Goodreads Scraper — Books, Reviews, Authors, Lists (`khadinakbar/goodreads-all-in-one-scraper`) Actor

Scrape Goodreads books, reviews, authors, lists, series, and search results from any URL or text query. MCP-ready, all-in-one, residential proxy default, $0.005 per result.

- **URL**: https://apify.com/khadinakbar/goodreads-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 All-in-One Scraper

**Scrape Goodreads books, reviews, authors, lists, series, and search results — from any Goodreads URL or text query — in one actor.**

Drop in a book URL, an author URL, a list URL, a series URL, a search URL, or just a plain text query like `sapiens yuval noah harari`. The actor auto-detects the input type and returns clean, flat JSON: book metadata with ISBN-13 and ratings distribution, full review text with reviewer profiles, author bios with bibliography, series in reading order, and ranked list / search results.

Built MCP-first for AI agents (Claude, ChatGPT, Gemini). Returns one record per entity with a stable `itemType` discriminator so an agent can route results without parsing surprises.

### When to use it

- **Authors / publishers** — pull every review on a comp title, slice by 1–2 stars to surface complaints, slice by 4–5 stars for ad copy quotes.
- **AI book recommenders** — ingest ratings, genres, descriptions, and similar-book signals to build personalized lists.
- **Market researchers** — track ranking and rating movement on genre lists ("Best Thrillers of 2025") across time.
- **Librarians and researchers** — bulk-pull series, awards, and edition metadata.
- **Book marketers** — discover top-ranked titles in a niche, find audience overlap via shelf tags.

### When NOT to use it

- Private user shelves that require login → not supported.
- Goodreads librarian features (edit metadata, merge editions) → not a scraper job.
- Real-time review streaming → run on a schedule instead.

### What you get per record

| `itemType` | Key fields |
|---|---|
| `book` | `title`, `author`, `authorUrl`, `averageRating`, `ratingsCount`, `reviewsCount`, `isbn`, `isbn13`, `asin`, `pages`, `publisher`, `publishedAt`, `language`, `format`, `genres[]`, `description`, `imageUrl`, `series`, `awards[]`, `ratingsDistribution` |
| `review` | `reviewerName`, `reviewerUrl`, `rating` (1–5), `reviewText`, `reviewDate`, `likesCount`, `commentsCount`, `shelves[]`, plus `title` + `author` of the book |
| `author` | `title` (author name), `description` (bio), `averageRating`, `ratingsCount`, `imageUrl` |
| `series` | per-book entries with `position`, `title`, `author`, `averageRating`, `ratingsCount` |
| `list_entry` | per-book entries from a Goodreads list (e.g. "Best Books of 2024"), with `position` |
| `search_result` | per-book search match with `position`, `title`, `author`, `averageRating` |

### Pricing

- **`$0.00005`** per actor start (charged once per run, per GB of RAM).
- **`$0.005`** per result pushed to the dataset.

Typical agent run (one book + 10 reviews): `$0.055`. A list of 50 entries: `$0.25`. No setup fee, no monthly minimum.

---

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `targets` | `string[]` | ✅ | Goodreads URLs OR free-text queries. Mix freely. |
| `resultsPerTarget` | `integer` | | Max records per target (default 50, max 500). For books this caps reviews. |
| `scrapeReviews` | `boolean` | | When `true` (default), book targets also pull reviews up to `resultsPerTarget`. |
| `reviewsLanguage` | `enum` | | `all`, `en`, `es`, `fr`, `de`, `it`, `pt`, `nl`, `ru`, `ja`, `zh`, `ko`. Default `all`. |
| `minRating` | `integer` | | Skip reviews below this 1-5 rating. Default `1`. |
| `maxRating` | `integer` | | Skip reviews above this 1-5 rating. Default `5`. |
| `responseFormat` | `enum` | | `detailed` (default, every field) or `concise` (token-efficient for AI agents). |
| `proxyConfiguration` | `object` | | Defaults to Apify residential — recommended. |

#### Example: book + reviews

```json
{
  "targets": ["https://www.goodreads.com/book/show/40097951-the-silent-patient"],
  "resultsPerTarget": 30,
  "scrapeReviews": true,
  "minRating": 1,
  "maxRating": 2
}
````

Returns one `book` record + up to 30 `review` records filtered to 1–2 star (negative reviews only).

#### Example: text query → top matches

```json
{
  "targets": ["sapiens yuval noah harari"],
  "resultsPerTarget": 10
}
```

Returns 10 `search_result` records ranked by Goodreads.

#### Example: author + their best-rated books

```json
{
  "targets": [
    "https://www.goodreads.com/author/show/3389.Brandon_Sanderson",
    "https://www.goodreads.com/list/show/1043.Best_Epic_Fantasy"
  ],
  "resultsPerTarget": 25
}
```

Returns one `author` record + up to 25 `list_entry` records.

***

### Calling from code

#### Node.js (Apify SDK)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/goodreads-all-in-one-scraper').call({
  targets: ['https://www.goodreads.com/book/show/40097951'],
  resultsPerTarget: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="<APIFY_TOKEN>")

run = client.actor("khadinakbar/goodreads-all-in-one-scraper").call(run_input={
    "targets": ["sapiens yuval noah harari"],
    "resultsPerTarget": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Claude / MCP client

The actor is exposed as the MCP tool `apify--goodreads-all-in-one-scraper`. Sample call:

```
Use the Goodreads All-in-One Scraper to fetch the top 5 negative reviews
(rating <= 2) of "The Silent Patient" so I can identify common complaints.
```

Claude will compose the input automatically.

***

### Output shape (concise mode)

```json
{
  "itemType": "book",
  "goodreadsId": "40097951",
  "url": "https://www.goodreads.com/book/show/40097951",
  "title": "The Silent Patient",
  "author": "Alex Michaelides",
  "averageRating": 4.16,
  "ratingsCount": 3430997,
  "reviewsCount": 295287,
  "isbn13": "9781250301697",
  "pages": 336,
  "publishedAt": "2019-02-05",
  "genres": ["Thriller", "Mystery", "Fiction"],
  "scrapedAt": "2026-05-13T21:09:00.000Z"
}
```

Use `responseFormat: "detailed"` for every parsed field (publisher, language, format, description, image URL, awards, ratings distribution, series link, etc.).

***

### How it works

1. Each target is classified — book / author / list / series / search URL / text query — by URL pattern.
2. A `CheerioCrawler` fetches each page through Apify residential proxies with a session pool that retires sessions on 403/429.
3. Book pages embed a Next.js Apollo JSON blob; the actor parses that for structured fields and falls back to CSS selectors on legacy templates.
4. Reviews are extracted from the same Apollo blob (first ~30) and paginated via `?page=N` for more.
5. Records are flat-shaped, charged per result, and pushed to the dataset.

### Reliability and anti-bot

- Apify residential proxies are enabled by default. Goodreads occasionally tightens anti-bot — residential keeps success rate above 95%.
- Session pool: 25 sessions, each retired after 30 uses or 3 errors.
- Five retries per request with exponential backoff.
- Failed requests are logged but never silently dropped — partial results are pushed and a `SUMMARY` is written to the run KV store.

### FAQ

**Does the actor need a Goodreads login?** No. Everything it reads is publicly accessible. Private shelves and friend feeds require login and are explicitly out of scope.

**Why didn't I get all the reviews I asked for?** Goodreads only renders ~30 reviews per page; many books have hundreds of thousands. Set `resultsPerTarget` to the max you actually need — runs scale linearly in pages and proxy cost.

**Can I filter reviews by date?** Not directly; filter the dataset downstream by `reviewDate`. Goodreads' sort order is "default" (relevance), which is non-chronological by design.

**What about Goodreads' official API?** Deprecated in 2020. Scraping is the only practical path for current Goodreads data.

**How fresh is the data?** Live — each run fetches Goodreads in real time. No cached layer.

**Can I export to CSV / Excel?** Yes. Open the run on Apify Console → Storage → Dataset → Export → CSV / XLSX / JSON.

**Does it work for non-English Goodreads regions?** Yes. Goodreads serves the same canonical URL globally. Use the `reviewsLanguage` filter to slice review content.

**What's the difference between this and the other Goodreads actors on the Store?** This is the only one that accepts every entity type in a single actor with auto-detection, ships MCP-ready descriptions for AI agents, and runs on residential proxies by default for 95%+ reliability.

### Changelog

- **1.0** (2026-05-13) — Initial release. Books, reviews, authors, lists, series, search; auto-detect targets; concise / detailed response modes; MCP-first descriptions; PPE pricing.

### Legal

This actor scrapes only publicly accessible Goodreads pages — content that any unauthenticated browser can view. You are responsible for ensuring your use of the data complies with Goodreads' Terms of Service, applicable copyright law (review text is copyrighted by the original reviewer; only fair-use excerpts and quantitative analysis are recommended), GDPR / CCPA when handling reviewer identifiers, and your contractual obligations to downstream consumers. Goodreads is a trademark of Goodreads LLC (Amazon). This actor is not affiliated with, endorsed by, or sponsored by Goodreads LLC. Use responsibly.

# Actor input Schema

## `targets` (type: `array`):

List of Goodreads URLs OR plain-text search queries. Each item can be a book URL (https://www.goodreads.com/book/show/40097951), author URL (/author/show/...), list URL (/list/show/...), series URL (/series/...), or a text query like 'sapiens yuval noah harari'. Auto-detected per item. NOT for private user shelves requiring login.

## `resultsPerTarget` (type: `integer`):

Cap on records returned per target. For books, this caps reviews collected (book metadata always returned). For lists and search, this caps entries. Defaults to 50. Maximum 500 per target to keep runs predictable. Not the total across all targets — applied per-target.

## `scrapeReviews` (type: `boolean`):

When true, opens each book URL and also pulls its reviews up to resultsPerTarget. When false, returns only the book metadata record (faster and cheaper). Has no effect on non-book targets. Defaults to true.

## `reviewsLanguage` (type: `string`):

Limit reviews to a specific language. Use ISO 639-1 codes like 'en', 'es', 'fr', or 'all' for no filter. Defaults to 'all'. Filtering uses Goodreads' built-in language tag — reviews with no detected language pass through 'all' only.

## `minRating` (type: `integer`):

Skip reviews below this star rating (1-5). Set to 1 to return every review. Use 4 for positive-only sentiment, 2 for negative-only when combined with maxRating. Applies only to review records, not books.

## `maxRating` (type: `integer`):

Skip reviews above this star rating (1-5). Set to 5 for no upper bound. Combine with minRating to slice review sentiment (e.g., min=1 max=2 returns only 1-2 star reviews). Applies only to review records.

## `responseFormat` (type: `string`):

Controls dataset item richness. 'concise' returns a token-efficient subset of fields (good for AI agents and recommendation systems). 'detailed' returns every parsed field including raw HTML descriptions and reviewer profile metadata. Defaults to 'detailed' for humans.

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

Apify proxy settings. Residential proxies are recommended for reliability — Goodreads occasionally tightens anti-bot. Datacenter works for low volume. Defaults to residential.

## Actor input object example

```json
{
  "targets": [
    "https://www.goodreads.com/book/show/40097951-the-silent-patient"
  ],
  "resultsPerTarget": 50,
  "scrapeReviews": true,
  "reviewsLanguage": "all",
  "minRating": 1,
  "maxRating": 5,
  "responseFormat": "detailed",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset items in JSON. Use the dataset\_schema views (overview / books / reviews) for filtered slices.

## `datasetUi` (type: `string`):

Browse the dataset in Apify Console with the predefined views.

## `books` (type: `string`):

Filtered dataset items where itemType=book.

## `reviews` (type: `string`):

Filtered dataset items where itemType=review.

## `summary` (type: `string`):

Counts per itemType, warnings, and runtime — written to key-value store key SUMMARY.

## `runConsole` (type: `string`):

Inspect logs, dataset, and KV store for this run.

# 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 = {
    "targets": [
        "https://www.goodreads.com/book/show/40097951-the-silent-patient",
        "sapiens yuval noah harari"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/goodreads-all-in-one-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 = {
    "targets": [
        "https://www.goodreads.com/book/show/40097951-the-silent-patient",
        "sapiens yuval noah harari",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/goodreads-all-in-one-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 '{
  "targets": [
    "https://www.goodreads.com/book/show/40097951-the-silent-patient",
    "sapiens yuval noah harari"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/goodreads-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goodreads Scraper — Books, Reviews, Authors, Lists",
        "description": "Scrape Goodreads books, reviews, authors, lists, series, and search results from any URL or text query. MCP-ready, all-in-one, residential proxy default, $0.005 per result.",
        "version": "1.1",
        "x-build-id": "3eJBOwSaj9DbeGPOt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~goodreads-all-in-one-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-goodreads-all-in-one-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/khadinakbar~goodreads-all-in-one-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-goodreads-all-in-one-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/khadinakbar~goodreads-all-in-one-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-goodreads-all-in-one-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Goodreads URLs or text queries",
                        "type": "array",
                        "description": "List of Goodreads URLs OR plain-text search queries. Each item can be a book URL (https://www.goodreads.com/book/show/40097951), author URL (/author/show/...), list URL (/list/show/...), series URL (/series/...), or a text query like 'sapiens yuval noah harari'. Auto-detected per item. NOT for private user shelves requiring login.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerTarget": {
                        "title": "Max results per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on records returned per target. For books, this caps reviews collected (book metadata always returned). For lists and search, this caps entries. Defaults to 50. Maximum 500 per target to keep runs predictable. Not the total across all targets — applied per-target.",
                        "default": 50
                    },
                    "scrapeReviews": {
                        "title": "Scrape reviews for book targets",
                        "type": "boolean",
                        "description": "When true, opens each book URL and also pulls its reviews up to resultsPerTarget. When false, returns only the book metadata record (faster and cheaper). Has no effect on non-book targets. Defaults to true.",
                        "default": true
                    },
                    "reviewsLanguage": {
                        "title": "Reviews language filter",
                        "enum": [
                            "all",
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ru",
                            "ja",
                            "zh",
                            "ko"
                        ],
                        "type": "string",
                        "description": "Limit reviews to a specific language. Use ISO 639-1 codes like 'en', 'es', 'fr', or 'all' for no filter. Defaults to 'all'. Filtering uses Goodreads' built-in language tag — reviews with no detected language pass through 'all' only.",
                        "default": "all"
                    },
                    "minRating": {
                        "title": "Minimum review rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Skip reviews below this star rating (1-5). Set to 1 to return every review. Use 4 for positive-only sentiment, 2 for negative-only when combined with maxRating. Applies only to review records, not books.",
                        "default": 1
                    },
                    "maxRating": {
                        "title": "Maximum review rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Skip reviews above this star rating (1-5). Set to 5 for no upper bound. Combine with minRating to slice review sentiment (e.g., min=1 max=2 returns only 1-2 star reviews). Applies only to review records.",
                        "default": 5
                    },
                    "responseFormat": {
                        "title": "Response shape for AI agents",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Controls dataset item richness. 'concise' returns a token-efficient subset of fields (good for AI agents and recommendation systems). 'detailed' returns every parsed field including raw HTML descriptions and reviewer profile metadata. Defaults to 'detailed' for humans.",
                        "default": "detailed"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are recommended for reliability — Goodreads occasionally tightens anti-bot. Datacenter works for low volume. Defaults to residential.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
