# Metacritic Scraper - Game and Movie Reviews (`parseforge/metacritic-scraper`) Actor

Scrape Metacritic metascores, critic reviews, and user ratings for games, movies, TV shows, and music. Extract release dates, platform availability, and developer details.

- **URL**: https://apify.com/parseforge/metacritic-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, News, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎮 Metacritic Scraper - Games, Movies & TV Scores

> 🚀 **Export Metacritic scores, reviews, and metadata in seconds.** No API key required - just run and download.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **Thousands of titles** · **Games, Movies & TV**

Metacritic is the web's most trusted aggregator of critic and user reviews for games, movies, and TV shows. This actor extracts structured data from Metacritic browse pages - Metascores, user scores, genres, descriptions, release dates, and more - without requiring any credentials or API keys.

Coverage spans all Metacritic titles across games (all platforms), movies, and TV shows. With over 925+ games just from 2024-2025, the full database contains tens of thousands of records across all categories.

| Who uses it | What they do |
|---|---|
| Game developers | Track competitor scores and genre trends |
| Publishers | Monitor user vs. critic score discrepancies |
| Journalists | Research score history for articles |
| Researchers | Analyze entertainment review data |
| Deal sites | Find top-rated games/movies |
| Recommendation engines | Build score-based recommendation datasets |

### 📋 What the Metacritic Scraper does

- Scrapes games, movies, or TV shows by media type
- Sorts results by Metascore (highest-rated first)
- Filters by platform (PS5, Xbox, PC, Nintendo Switch, etc.)
- Filters by minimum Metascore threshold
- Paginates through all results automatically
- Exports Metascore, user score, genre, release date, description, and more
- Includes direct Metacritic URLs for every record

> 💡 **Why it matters:** Metacritic scores directly influence purchasing decisions for millions of consumers and business decisions for publishers. Getting structured score data at scale requires this kind of automated extraction.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `maxItems` | Integer | Maximum number of items to scrape | 10 |
| `mediaType` | Select | game, movie, or tv | game |
| `platform` | Text | Filter games by platform slug (ps5, xbox-series-x, pc, nintendo-switch) | - |
| `minMetascore` | Integer | Only return items scoring at or above this value (0-100) | - |

**Example - Top PS5 games:**
```json
{
  "maxItems": 50,
  "mediaType": "game",
  "platform": "ps5"
}
````

**Example - Best movies with score 90+:**

```json
{
  "maxItems": 100,
  "mediaType": "movie",
  "minMetascore": 90
}
```

> ⚠️ **Good to Know:** Platform filtering only applies to games. For movies and TV, leave `platform` blank. Results are sorted by Metascore descending by default.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | String | Cover image URL |
| 📌 `title` | String | Game, movie, or TV show title |
| 🏷️ `type` | String | Media type: game, movie, or tv |
| 🎮 `platform` | String | Platform when platform filter is applied |
| ⭐ `metascore` | Number | Critic Metascore (0-100) |
| 👥 `userscore` | Number | User Score (0.0-10.0) |
| 📅 `releaseDate` | String | Release date (YYYY-MM-DD) |
| 🎭 `genre` | String | Primary genre |
| 📝 `description` | String | Synopsis or description |
| 🔗 `url` | String | Metacritic URL |
| 🕒 `scrapedAt` | String | ISO timestamp |
| ❌ `error` | String | Error message if applicable |

**Sample record:**

```json
{
  "imageUrl": "https://www.metacritic.com/a/img/resize/catalog/provider/6/3/6-1-4763-13.jpg?auto=webp&fit=cover&height=300&quality=80&width=200",
  "title": "The Legend of Zelda: Ocarina of Time",
  "type": "game",
  "platform": null,
  "metascore": 99,
  "userscore": 9.1,
  "releaseDate": "1998-11-23",
  "genre": "Open-World Action",
  "description": "As a young boy, Link is tricked by Ganondorf, the King of the Gerudo Thieves...",
  "url": "https://www.metacritic.com/game/the-legend-of-zelda-ocarina-of-time/",
  "scrapedAt": "2026-05-21T23:57:06.258Z"
}
```

**Second sample (movie):**

```json
{
  "imageUrl": "https://www.metacritic.com/a/img/resize/catalog/provider/2/2/2-dd018c5d82b77507bdac403f5f7c217b.jpg?auto=webp&fit=cover&height=300&quality=80&width=200",
  "title": "The Conformist",
  "type": "movie",
  "platform": null,
  "metascore": 100,
  "userscore": 7.8,
  "releaseDate": "1970-10-22",
  "genre": "Drama",
  "description": "Set in Rome in the 1930s, this re-release of Bernardo Bertolucci's 1970 breakthrough feature...",
  "url": "https://www.metacritic.com/movie/the-conformist-re-release/",
  "scrapedAt": "2026-05-21T23:57:06.258Z"
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🌐 No login needed | Fully public data extraction |
| ⚡ Fast SSR parsing | Reads Nuxt.js server-side data directly |
| 🎮 All media types | Games, movies, and TV shows |
| 🔍 Smart filtering | Platform, score threshold, and pagination |
| 📦 Clean output | 12 structured fields per record |
| 🛡️ Cloudflare-resilient | Uses real browser rendering |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Other tools |
|---|---|---|---|
| All media types | ✅ | Partial | Partial |
| Platform filtering | ✅ | Manual | Rarely |
| Metascore + Userscore | ✅ | Manual | Sometimes |
| Pagination support | ✅ | Complex | Varies |
| Real-time data | ✅ | Yes | Varies |
| No setup required | ✅ | No | Varies |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Search for **Metacritic Scraper** in the Apify Store
3. Configure your input (media type, max items, optional filters)
4. Click **Start** and wait for results
5. Download as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### 🎮 Game Industry

Track Metascores for competitive intelligence. Compare first-party vs. third-party title performance. Identify which platforms and genres score highest.

#### 🎬 Entertainment & Media

Build recommendation engines using critic + user score data. Analyze score trends over time. Identify hidden gems (high user scores, lower critic scores).

#### 📊 Market Research

Score data reveals consumer sentiment at scale. Cross-reference with sales data. Study genre popularity through release cadence.

#### 🤖 Data Science

Train recommendation models on labeled review data. Study critic-audience alignment. Build scoring prediction models.

### 🔌 Automating Metacritic Scraper

Connect to your workflows via Apify integrations:

- **Make (Integromat)** - trigger scraping on a schedule, pipe to Google Sheets
- **Zapier** - push results to Airtable, Notion, or Slack
- **Slack** - get daily top-rated game alerts
- **Google Sheets** - maintain a live score database
- **Webhooks** - trigger downstream APIs when new data arrives

### 🌟 Beyond business use cases

#### 🔬 Academic Research

Study the relationship between critic consensus and commercial success. Analyze how platform exclusivity affects review scores.

#### 🎨 Creative Projects

Build score-based recommendation bots. Create data visualizations of gaming history.

#### 🌍 Non-profit & Education

Gaming history preservation. Educational datasets for media studies courses.

#### 🧪 Experimentation

Test recommendation algorithms. Build personal game backlog trackers.

### 🤖 Ask an AI assistant about this scraper

You can ask ChatGPT, Claude, or any AI assistant: *"What can I do with Metacritic game score data from Apify?"* - you'll get instant ideas for analysis, automation, and integration.

### ❓ Frequently Asked Questions

#### ❓ Does this require a Metacritic account?

No. All data is publicly available on Metacritic without login.

#### ❓ How many results can I get?

Free users: up to 10 items. Paid users: up to 1,000,000 items.

#### ❓ What platforms are supported for game filtering?

Common values: `ps5`, `xbox-series-x`, `pc`, `nintendo-switch`, `nintendo-switch-2`, `ps4`, `xbox-one`. Use the slug format shown in Metacritic URLs.

#### ❓ How is data sorted?

Results are sorted by Metascore descending (highest-rated first).

#### ❓ How current is the data?

Data is scraped in real-time from Metacritic. There is no caching.

#### ❓ Can I filter by release year?

Not directly in the input - the actor scrapes all-time top results by default. For year filtering, use `releaseDate` in post-processing.

#### ❓ Why is `platform` null when I don't filter?

The Metacritic browse page shows all-platform results without indicating individual platforms per title. Use the `platform` input to filter by a specific platform.

#### ❓ Does this scrape individual review text?

Not at this time. It extracts aggregate scores and metadata from browse pages.

#### ❓ What's the difference between Metascore and User Score?

Metascore is a weighted average of professional critic reviews (0-100). User Score is an average of user-submitted reviews (0-10 scale, shown as 0-10).

#### ❓ How fast does it scrape?

Approximately 24 items per page load, ~3-5 seconds per page. For 100 items: ~20-25 seconds.

### 🔌 Integrate with any app

Apify supports integrations with: Zapier, Make, n8n, Google Sheets, Airtable, Slack, Discord, Notion, Monday.com, HubSpot, Salesforce, BigQuery, PostgreSQL, MongoDB, REST APIs, and more via webhooks.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database - IATA codes, coordinates, runway data |
| [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper) | Licensed broker and firm registration data |
| [Copart Public Search Scraper](https://apify.com/parseforge/copart-public-search-scraper) | Salvage auction listings and vehicle data |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more high-quality data extraction actors.

***

*This actor is not affiliated with, endorsed by, or sponsored by Metacritic or CBS Interactive. It scrapes publicly available data in accordance with standard web data extraction practices. Use responsibly and review Metacritic's terms of service before use in commercial applications.*

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `mediaType` (type: `string`):

Type of media to scrape from Metacritic.

## `platform` (type: `string`):

Filter games by platform (e.g. ps5, xbox-series-x, pc, nintendo-switch). Leave blank for all platforms.

## `minMetascore` (type: `integer`):

Only return items with a Metascore at or above this value (0-100). Leave blank for no filter.

## Actor input object example

```json
{
  "maxItems": 10,
  "mediaType": "game"
}
```

# Actor output Schema

## `imageUrl` (type: `string`):

URL of the cover image.

## `title` (type: `string`):

Title of the game, movie, or TV show.

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

Media type: game, movie, or tv.

## `platform` (type: `string`):

Platform (for games) or null for movies/TV.

## `metascore` (type: `string`):

Critic Metascore (0-100) or null if not yet scored.

## `userscore` (type: `string`):

User Score (0.0-10.0) or null if not yet scored.

## `releaseDate` (type: `string`):

Release date in YYYY-MM-DD format.

## `genre` (type: `string`):

Primary genre.

## `description` (type: `string`):

Short description or synopsis.

## `url` (type: `string`):

Metacritic URL for the item.

## `scrapedAt` (type: `string`):

ISO timestamp when this record was scraped.

## `error` (type: `string`):

Error message if scraping failed.

# 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 = {
    "maxItems": 10,
    "mediaType": "game"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/metacritic-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 = {
    "maxItems": 10,
    "mediaType": "game",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/metacritic-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 '{
  "maxItems": 10,
  "mediaType": "game"
}' |
apify call parseforge/metacritic-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Metacritic Scraper - Game and Movie Reviews",
        "description": "Scrape Metacritic metascores, critic reviews, and user ratings for games, movies, TV shows, and music. Extract release dates, platform availability, and developer details.",
        "version": "0.1",
        "x-build-id": "qcxKN5NYCMZBLIulI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~metacritic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-metacritic-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/parseforge~metacritic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-metacritic-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/parseforge~metacritic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-metacritic-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mediaType": {
                        "title": "Media Type",
                        "enum": [
                            "game",
                            "movie",
                            "tv"
                        ],
                        "type": "string",
                        "description": "Type of media to scrape from Metacritic."
                    },
                    "platform": {
                        "title": "Platform (Games only)",
                        "type": "string",
                        "description": "Filter games by platform (e.g. ps5, xbox-series-x, pc, nintendo-switch). Leave blank for all platforms."
                    },
                    "minMetascore": {
                        "title": "Minimum Metascore",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return items with a Metascore at or above this value (0-100). Leave blank for no filter."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```