# Metacritic Reviews & Scores Scraper (`fetch_cat/metacritic-reviews-scores-scraper`) Actor

Scrape Metacritic titles, Metascores, user scores, review counts, release details, rankings, summaries, and review snippets.

- **URL**: https://apify.com/fetch\_cat/metacritic-reviews-scores-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Games, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.36 / 1,000 title saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## Metacritic Reviews & Scores Scraper

Extract Metacritic titles, scores, release details, rankings, and optional public review snippets from movies, TV shows, games, and music pages.

### What does Metacritic Reviews & Scores Scraper do?

Metacritic Reviews & Scores Scraper turns public Metacritic pages into structured datasets.

It can collect title pages from browse rankings, search results, and direct detail URLs.

Use it to monitor Metascores, user scores, critic review volume, public user review volume, genres, summaries, and release dates.

When enabled, it can also add a small set of public critic and user review snippets to each title row.

### Who is this Metacritic scraper for?

Media research teams use it to compare titles across categories.

Game publishers use it to watch critic reception and review counts.

Film marketers use it to build research lists for new releases and evergreen rankings.

SEO teams use it to enrich review roundups and content briefs.

Data analysts use it to combine Metacritic scores with internal market data.

### Why scrape Metacritic with this actor?

Metacritic pages are useful but not convenient for repeat analysis.

This actor gives you consistent rows that can be exported to JSON, CSV, Excel, Google Sheets, or downstream systems.

You can run small searches or larger ranking pages without manually copying data from the website.

### What Metacritic data can I extract?

| Field | Description |
| --- | --- |
| `url` | Metacritic title URL |
| `contentType` | Movie, TV, game, or music |
| `name` | Title name shown on Metacritic |
| `releaseDate` | Public release date when available |
| `platformsNetwork` | Game platforms or TV network signals when available |
| `genres` | Public genre list |
| `metascore` | Critic Metascore |
| `userScore` | Public user score when available |
| `criticReviewCount` | Number of critic reviews behind the score |
| `userReviewCount` | Number of public user ratings or reviews detected |
| `summary` | Metacritic summary or synopsis |
| `rankingContext` | Browse rank or search context |
| `reviewSnippets` | Optional critic/user snippets |
| `fetchedAt` | Timestamp for the scrape |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `result` | Per Metacritic title record produced | $0.69 / 1,000 | $0.6 / 1,000 | $0.468 / 1,000 | $0.36 / 1,000 | $0.24 / 1,000 | $0.168 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to scrape Metacritic rankings

1. Open the actor on Apify.
2. Add a Metacritic browse URL such as `https://www.metacritic.com/browse/movie/`.
3. Set `maxItems` to the number of titles you want.
4. Keep `includeReviews` off for a fast score run.
5. Start the actor.
6. Export the dataset from the Storage tab.

### How to scrape a Metacritic search query

Enter a search term in `query`, for example `elden ring`.

The actor opens the public Metacritic search page, finds matching title pages, and saves structured title records.

Use search mode when you know a title, franchise, publisher, album, or show name.

### How to scrape a Metacritic title detail page

Paste a title URL in `startUrls`.

Examples include:

- `https://www.metacritic.com/movie/dekalog-1988/`
- `https://www.metacritic.com/game/elden-ring/`
- `https://www.metacritic.com/tv/breaking-bad/`

The actor saves one row for each detail URL.

### Input settings

| Key | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Exact Metacritic browse, search, or title pages. |
| `query` | string | Search term when you want the actor to search Metacritic for you. |
| `category` | string | `movie`, `tv`, `game`, or `music` default browse category. |
| `browseSort` | string | Ranking context for browse runs, such as `metascore`. |
| `year` | integer | Optional year context for your run setup. |
| `maxItems` | integer | Maximum number of title records to save. |
| `includeReviews` | boolean | Turn on to fetch short public critic/user review excerpts. |
| `maxReviewSnippets` | integer | Maximum critic snippets and user snippets per title. |
| `proxyConfiguration` | object | Apify proxy settings. Try default/datacenter proxy first; use residential only if blocked. |

### Verified public examples

Ready-to-run Apify Store examples verified in post-publish QA:

- [Metacritic movie detail score](https://apify.com/fetch_cat/metacritic-reviews-scores-scraper/examples/metacritic-movie-detail-score)
- [Metacritic game search review snippets](https://apify.com/fetch_cat/metacritic-reviews-scores-scraper/examples/metacritic-game-search-review-snippets)
- [Metacritic movie browse ranking](https://apify.com/fetch_cat/metacritic-reviews-scores-scraper/examples/metacritic-movie-browse-ranking)

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.metacritic.com/browse/movie/" }
  ],
  "maxItems": 10,
  "includeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
````

### Example output

```json
{
  "url": "https://www.metacritic.com/movie/dekalog-1988/",
  "contentType": "movie",
  "name": "Dekalog (1988)",
  "releaseDate": "1996-03-22",
  "genres": ["Drama"],
  "metascore": 100,
  "userScore": null,
  "criticReviewCount": 13,
  "userReviewCount": 256,
  "summary": "This masterwork by Krzysztof Kieślowski...",
  "rankingContext": "Rank 1 on Metacritic browse page",
  "reviewSnippets": [],
  "fetchedAt": "2026-07-04T00:00:00.000Z"
}
```

### Tips for best results

Start with a small `maxItems` value.

Confirm the output fields you need.

Then increase the limit for scheduled or bulk runs.

Use detail URLs for exact titles.

Use browse URLs for rankings.

Use query mode for discovery.

Disable review snippets when you only need scores.

Enable review snippets for editorial research.

### Metacritic categories

Movies are supported.

TV pages are supported.

Game pages are supported.

Music pages are supported.

Availability of individual fields varies by title type and Metacritic page content.

### Integrations

Send results to Google Sheets for editorial tracking.

Export CSV files for research teams.

Connect the dataset to BI dashboards.

Use webhooks to start enrichment after a run succeeds.

Combine title rows with internal campaign, release, or sales data.

### Input recipes

These are safe pre-publication example inputs. Public ready-to-run Example links will be added only after the actor is published and Publisher creates verified tasks.

**Movie detail enrichment**

```json
{
  "startUrls": [{ "url": "https://www.metacritic.com/movie/the-godfather/" }],
  "maxItems": 1,
  "includeReviews": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] }
}
```

**Game search with review snippets**

```json
{
  "query": "elden ring",
  "maxItems": 2,
  "includeReviews": true,
  "maxReviewSnippets": 1,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] }
}
```

**Movie ranking sample**

```json
{
  "startUrls": [{ "url": "https://www.metacritic.com/browse/movie/" }],
  "category": "movie",
  "browseSort": "metascore",
  "maxItems": 5,
  "includeReviews": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] }
}
```

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/metacritic-reviews-scores-scraper').call({
  query: 'elden ring',
  maxItems: 5,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/metacritic-reviews-scores-scraper').call(run_input={
    'query': 'elden ring',
    'maxItems': 5,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~metacritic-reviews-scores-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"elden ring","maxItems":5}'
```

### MCP usage

You can run this actor from Claude Code or Claude Desktop through Apify MCP.

Use the MCP URL with the actor tool enabled:

```text
https://mcp.apify.com/?tools=fetch_cat/metacritic-reviews-scores-scraper
```

Add it in Claude CLI:

```bash
claude mcp add apify-metacritic "https://mcp.apify.com/?tools=fetch_cat/metacritic-reviews-scores-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-metacritic": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/metacritic-reviews-scores-scraper"
    }
  }
}
```

Example prompt ideas for MCP:

- "Scrape the top 10 Metacritic movie rankings and summarize the highest scoring titles."
- "Find Metacritic results for Elden Ring and return the scores and review counts."
- "Collect review snippets for this Metacritic movie URL and format them as a table."

### Data quality notes

Scores and counts are captured from public pages.

Some title types do not show every field.

A missing value means the public page did not expose that value during the run.

The actor avoids saving obvious challenge pages as data.

### Troubleshooting

#### Why did my run return fewer titles than requested?

The page may contain fewer matching titles than your `maxItems` value, or Metacritic may not expose more results on that URL.

Try a broader browse URL or a different query.

#### Why are review snippets empty?

Review snippets are only collected when `includeReviews` is enabled.

Some pages also have limited public review text.

#### Why is userScore null?

Some pages do not expose a user score in a reliable machine-readable place.

The row still includes the Metascore and review counts when available.

### Legal and ethical use

This actor extracts publicly available information from Metacritic pages.

Use it responsibly and respect applicable laws, platform terms, and privacy rules.

Do not use the actor to overload websites or republish content in a way that violates rights.

### FAQ

#### Can I scrape reviews as separate rows?

Not in this version. Review snippets are nested inside each title row and bounded by `maxReviewSnippets`.

#### Why did a direct title URL return one row?

Detail URL mode is designed for enrichment of known Metacritic pages, so each valid detail URL maps to one output row.

### Related scrapers

- [Metacritic Reviews & Scores Scraper](https://apify.com/fetch_cat/metacritic-reviews-scores-scraper) for Metacritic title score workflows.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) for editorial monitoring workflows.
- [Google Trends Scraper](https://apify.com/fetch_cat/google-trends-scraper) for audience interest research workflows.

### Support

If a run fails, contact support with the run ID or run URL, exact input JSON, expected output, actual output, and one reproducible public URL such as a public Metacritic title or browse page.

Mention whether you used start URLs, query mode, or review snippets. Small reproducible inputs are easiest to diagnose.

### Changelog

- 2026-07-28 - Feature: Added ready-to-run Apify Store example tasks

- 2026-07-28 - Feature: Launched Metacritic Reviews & Scores Scraper on Apify Store
  - This actor is now publicly available in the Apify Store.

# Actor input Schema

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

Metacritic browse, search, or title detail URLs. If omitted, the actor uses the selected category browse page or query.

## `query` (type: `string`):

Optional Metacritic search term, for example a movie, game, show, artist, or album name.

## `category` (type: `string`):

Default Metacritic category to browse when no Start URLs are provided.

## `browseSort` (type: `string`):

Records the intended ranking context for browse runs. Metacritic may decide the exact ordering in the page URL you provide.

## `year` (type: `integer`):

Optional release year context to include in your run setup. For exact year-filtered pages, provide a Metacritic URL in Start URLs.

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

Maximum number of Metacritic title records to save.

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

Fetch public critic and user review pages for each title and include short snippets.

## `maxReviewSnippets` (type: `integer`):

Maximum critic snippets and maximum user snippets to collect for each title when Include review snippets is enabled.

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

Optional proxy settings. Datacenter/automatic proxy is recommended first; use residential only if your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.metacritic.com/browse/movie/"
    }
  ],
  "query": "elden ring",
  "category": "movie",
  "browseSort": "metascore",
  "maxItems": 20,
  "includeReviews": false,
  "maxReviewSnippets": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.metacritic.com/browse/movie/"
        }
    ],
    "query": "elden ring"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/metacritic-reviews-scores-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": [{ "url": "https://www.metacritic.com/browse/movie/" }],
    "query": "elden ring",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/metacritic-reviews-scores-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": [
    {
      "url": "https://www.metacritic.com/browse/movie/"
    }
  ],
  "query": "elden ring"
}' |
apify call fetch_cat/metacritic-reviews-scores-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Metacritic Reviews & Scores Scraper",
        "description": "Scrape Metacritic titles, Metascores, user scores, review counts, release details, rankings, summaries, and review snippets.",
        "version": "0.1",
        "x-build-id": "pY3wG2zWC3pAJjZ2a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~metacritic-reviews-scores-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-metacritic-reviews-scores-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/fetch_cat~metacritic-reviews-scores-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-metacritic-reviews-scores-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/fetch_cat~metacritic-reviews-scores-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-metacritic-reviews-scores-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": "Metacritic browse, search, or title detail URLs. If omitted, the actor uses the selected category browse page or query.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional Metacritic search term, for example a movie, game, show, artist, or album name."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "movie",
                            "tv",
                            "game",
                            "music"
                        ],
                        "type": "string",
                        "description": "Default Metacritic category to browse when no Start URLs are provided.",
                        "default": "movie"
                    },
                    "browseSort": {
                        "title": "Browse sort context",
                        "enum": [
                            "metascore",
                            "user_score",
                            "newest",
                            "popular"
                        ],
                        "type": "string",
                        "description": "Records the intended ranking context for browse runs. Metacritic may decide the exact ordering in the page URL you provide.",
                        "default": "metascore"
                    },
                    "year": {
                        "title": "Year context",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Optional release year context to include in your run setup. For exact year-filtered pages, provide a Metacritic URL in Start URLs."
                    },
                    "maxItems": {
                        "title": "Maximum titles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Metacritic title records to save.",
                        "default": 20
                    },
                    "includeReviews": {
                        "title": "Include review snippets",
                        "type": "boolean",
                        "description": "Fetch public critic and user review pages for each title and include short snippets.",
                        "default": false
                    },
                    "maxReviewSnippets": {
                        "title": "Review snippets per type",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum critic snippets and maximum user snippets to collect for each title when Include review snippets is enabled.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Datacenter/automatic proxy is recommended first; use residential only if your run is blocked.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
