# Rotten Tomatoes Scraper | Movie and TV Ratings (`parseforge/rottentomatoes-scraper`) Actor

Extract movies and TV shows from Rotten Tomatoes with Tomatometer score, audience score, cast, director, genre, runtime, synopsis, and critic reviews. Build entertainment databases, recommendation engines, sentiment dashboards, and review analysis pipelines at scale.

- **URL**: https://apify.com/parseforge/rottentomatoes-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Marketing, Other
- **Stats:** 2 total users, 1 monthly users, 100.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)

## 🍅 Rotten Tomatoes Scraper

> 🚀 **Export Tomatometer scores, audience ratings, cast, and streaming info from Rotten Tomatoes in seconds.** No API key required.

> 🕒 **Last updated:** 2026-05-22 · **📊 17 fields** per record · **Movies & TV shows** · **Real-time data**

The Rotten Tomatoes Scraper lets you extract structured data from Rotten Tomatoes browse pages - movies and TV shows with Tomatometer scores, audience scores, critics consensus, genre, cast, director, runtime, content rating, and streaming availability. All data is scraped in real-time from Rotten Tomatoes' public interface.

Browse the most popular, newest, or top-rated titles across both movies and TV shows. Each record includes full detail-page data: critics consensus text, full cast list, streaming services where you can watch it today, and more.

### Coverage

- **Movies**: Popular, Newest, Top Rated (Box Office)
- **TV Shows**: Popular, Newest, Top Rated series
- **17 fields** per record including scores, cast, streaming services
- **Real-time** - data reflects current Rotten Tomatoes scores

### Target Audience / Use Cases

| Who | What they use it for |
|-----|---------------------|
| Film researchers | Track critic vs. audience score divergences over time |
| Streaming analysts | Identify which services carry top-rated content |
| Content creators | Build watchlists and recommendation engines |
| Data journalists | Cover trends in Hollywood critic reception |
| Developers | Power movie recommendation apps and databases |
| Entertainment businesses | Competitive analysis of streaming catalogs |

### 📋 What the Rotten Tomatoes Scraper does

- Scrapes the browse/discovery pages for movies or TV shows
- Retrieves Tomatometer (critics) and Audience Score for each title
- Extracts the critics consensus summary text
- Pulls cast, director, genre, content rating, and runtime from detail pages
- Collects streaming service availability (Netflix, Hulu, Disney+, etc.)
- Paginates automatically to collect up to 1,000,000 items

> 💡 **Why it matters:** Rotten Tomatoes scores are the gold standard for film criticism. Researchers, developers, and content teams use them to benchmark quality, study audience vs. critic alignment, and build smarter recommendation systems.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `browseType` | select | `movies` | Browse movies or TV shows |
| `sortBy` | select | `popular` | Sort by: popular, newest, or top_rated |
| `maxItems` | integer | 10 | Max records to return (free: 10, paid: up to 1,000,000) |

**Example - Top 50 popular movies:**
```json
{
  "browseType": "movies",
  "sortBy": "popular",
  "maxItems": 50
}
````

**Example - Top rated TV shows:**

```json
{
  "browseType": "tv",
  "sortBy": "top_rated",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Free plan users are limited to 10 items. Upgrade to a paid plan to scrape thousands of titles at once. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Poster image URL |
| 📝 `title` | string | Title of the movie or TV show |
| 📅 `year` | string | Release year |
| 🎬 `type` | string | "movie" or "tv" |
| 🔗 `url` | string | Rotten Tomatoes page URL |
| 🆔 `id` | string | RT slug identifier |
| 🍅 `tomatoScore` | integer | Tomatometer score (0-100) |
| 🍿 `audienceScore` | integer | Audience score (0-100) |
| 💬 `consensus` | string | Critics consensus summary |
| 🏷️ `genre` | string | Genres (comma-separated) |
| 🔞 `rating` | string | Content rating (PG-13, R, TV-MA, etc.) |
| ⏱️ `runtime` | string | Runtime (e.g. "2h 36m") |
| 🎥 `director` | string | Director(s) |
| 👥 `cast` | array | Main cast members |
| 📺 `streamingServices` | array | Where to watch |
| 🕐 `scrapedAt` | string | ISO timestamp |
| ❌ `error` | string | Error message if any |

**Sample record 1 - Movie:**

```json
{
  "imageUrl": "https://resizing.flixster.com/6EeDwgqrKFi1ADO4k4VzZtrOVhM=...",
  "title": "Project Hail Mary",
  "year": "2026",
  "type": "movie",
  "url": "https://www.rottentomatoes.com/m/project_hail_mary",
  "id": "project_hail_mary",
  "tomatoScore": 94,
  "audienceScore": 95,
  "consensus": "A visually dazzling space odyssey that's carried along effortlessly by the gravitational pull of Ryan Gosling at his most winning, Project Hail Mary is a near-miraculous fusion of smarts and heart.",
  "genre": "Sci-Fi, Adventure",
  "rating": "PG-13",
  "runtime": "2h 36m",
  "director": "Phil Lord, Christopher Miller",
  "cast": ["Ryan Gosling", "Sandra Hüller", "James Ortiz", "Lionel Boyce"],
  "streamingServices": ["Fandango at Home"],
  "scrapedAt": "2026-05-22T01:23:10.464Z",
  "error": null
}
```

**Sample record 2 - Movie:**

```json
{
  "imageUrl": "https://resizing.flixster.com/WEelDTQoFz53v0hGRRC1rZ-3uxY=...",
  "title": "Send Help",
  "year": "2026",
  "type": "movie",
  "url": "https://www.rottentomatoes.com/m/send_help",
  "id": "send_help",
  "tomatoScore": 92,
  "audienceScore": 86,
  "consensus": "Putting director Sam Raimi's penchant for diabolical mayhem to great use, Send Help doesn't need any assistance in thrills thanks to a very game Rachel McAdams and Dylan O'Brien along with a viciously clever script.",
  "genre": "Horror, Comedy, Mystery & Thriller",
  "rating": "R",
  "runtime": "1h 53m",
  "director": "Sam Raimi",
  "cast": ["Rachel McAdams", "Dylan O'Brien", "Edyll Ismail", "Dennis Haysbert", "Xavier Samuel"],
  "streamingServices": ["Fandango at Home", "Disney+", "Hulu"],
  "scrapedAt": "2026-05-22T01:23:10.969Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | This Actor |
|---------|-----------|
| ✅ No API key required | Public interface, no credentials needed |
| ✅ Real-time data | Scores scraped at run time, always current |
| ✅ Full detail data | Cast, director, consensus, streaming from detail pages |
| ✅ Movies + TV | Both content types in a single actor |
| ✅ Streaming availability | Shows where to watch each title today |
| ✅ Critics consensus | Full text summary from professional critics |
| ✅ JSON/CSV/Excel export | Download in any format from Apify dataset |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Old RT API |
|---------|-----------|----------------|-----------|
| Automated extraction | ✅ Yes | ❌ No | ✅ Yes (deprecated) |
| Real-time scores | ✅ Yes | ✅ Yes | ❌ Discontinued |
| Critics consensus | ✅ Yes | ✅ Yes | ❌ Not included |
| Streaming services | ✅ Yes | ✅ Yes | ❌ Not included |
| Bulk export | ✅ CSV/JSON/Excel | ❌ No | ❌ Discontinued |
| Free tier | ✅ 10 items | ✅ Yes | ❌ Discontinued |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Rotten Tomatoes Scraper actor page
3. Set `browseType` to "movies" or "tv"
4. Choose a `sortBy` option: popular, newest, or top\_rated
5. Set `maxItems` to limit the number of results (free: 10, paid: up to 1,000,000)
6. Click "Start" and wait a few seconds
7. Download your dataset as JSON, CSV, or Excel

### 💼 Business use cases

#### Streaming Platform Analysis

Track which platforms carry the highest-rated titles. Compare Netflix vs. Hulu vs. Disney+ by average Tomatometer score across their libraries. Identify gaps in streaming catalogs.

#### Film Recommendation Engines

Power recommendation systems with real critic and audience scores. Build filters by genre, rating, runtime, and score. Use cast and director data to find similar titles.

#### Entertainment Journalism

Monitor how scores change over time. Track the gap between critic reception and audience response. Identify the most divisive films of the year.

#### Market Research

Analyze genre trends in what critics and audiences prefer. Study how content ratings correlate with scores. Build competitive intelligence dashboards for entertainment businesses.

### 🔌 Automating Rotten Tomatoes Scraper

Connect this actor to automation platforms to build end-to-end workflows:

- **Make (Integromat)** - Trigger on schedule, push records to Google Sheets or Airtable
- **Zapier** - Auto-send new top-rated movies to Slack or email
- **n8n** - Build custom ETL pipelines with RT data
- **Apify Schedules** - Run daily/weekly to track score changes over time
- **Webhooks** - Push dataset results to your own API endpoint

### 🌟 Beyond business use cases

#### Personal Watchlists

Build your own "best of" lists filtered by genre, score threshold, and streaming service. Never miss a great movie again.

#### Academic Research

Study the sociology of film criticism. Analyze how scores correlate with box office, demographics, or cultural events.

#### Non-profit & Education

Film schools and media literacy programs can use real critic data to teach analysis and evaluation skills.

#### Developer Experimentation

Build movie trivia apps, score prediction models, or recommendation bots. RT data provides a rich training set for ML projects.

### 🤖 Ask an AI assistant about this scraper

Want to know the best way to use this data? Ask an AI assistant:

- "How do I filter movies by Tomatometer score above 80?"
- "Which streaming service has the most top-rated movies in this dataset?"
- "How do I track score changes by running this scraper weekly?"

### ❓ Frequently Asked Questions

**Q: Does this require a Rotten Tomatoes API key?**
A: No. This actor scrapes the public Rotten Tomatoes website and requires no API key or login.

**Q: How many items can I scrape?**
A: Free users get 10 items per run. Paid users can scrape up to 1,000,000 items.

**Q: How current is the data?**
A: All data is scraped in real-time at the moment you run the actor. Scores reflect what Rotten Tomatoes shows right now.

**Q: Can I scrape both movies and TV shows?**
A: Yes. Use the `browseType` input to switch between "movies" and "tv".

**Q: What streaming services are covered?**
A: Netflix, Hulu, Disney+, Prime Video, Fandango at Home, Apple TV+, and others as RT lists them.

**Q: Why are `consensus`, `director`, and `runtime` sometimes null for TV shows?**
A: TV series on Rotten Tomatoes often don't list a single director or runtime. Consensus is not always written for every series.

**Q: Is the data legal to scrape?**
A: This actor accesses publicly available information from Rotten Tomatoes. Always review the site's terms of service and use the data responsibly.

**Q: Can I download the data as CSV or Excel?**
A: Yes. Apify datasets support export to JSON, CSV, Excel (XLSX), and XML from the dataset page.

**Q: How fast does it run?**
A: Each run takes a few seconds per item since it fetches detail pages. 5 items typically completes in under 10 seconds.

**Q: What does `type` field contain?**
A: "movie" for films and "tv" for TV series. Helps distinguish mixed result sets if you build further pipelines.

### 🔌 Integrate with any app

Export your Rotten Tomatoes dataset to:

- **Google Sheets** via Apify's Google Sheets integration
- **Airtable** via Make or Zapier
- **Slack** - auto-post new top-rated movies to a channel
- **Notion** - build a living movie database
- **PostgreSQL / MySQL** - import JSON via Apify API
- **Power BI / Tableau** - connect via CSV export
- **BigQuery** - load JSON datasets for analytics
- **REST APIs** - use Apify webhooks to push data to your backend

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [CoinMarketCap Scraper](https://apify.com/parseforge/coinmarketcap-scraper) | Real-time crypto prices, market cap, and rankings |
| [IMDB Scraper](https://apify.com/apify/imdb-scraper) | Movie ratings, awards, and filmographies from IMDB |
| [YouTube Scraper](https://apify.com/bernardo/youtube-scraper) | Video stats, comments, and channel data |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ data scrapers covering finance, entertainment, jobs, and more.

***

**Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or associated with Rotten Tomatoes or Fandango Media. All data is publicly available on the Rotten Tomatoes website. Use responsibly and in accordance with Rotten Tomatoes' Terms of Service.

# Actor input Schema

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

Choose whether to scrape movies or TV shows.

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

Choose how to sort the results.

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

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

## Actor input object example

```json
{
  "browseType": "movies",
  "sortBy": "popular",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "browseType": "movies",
    "sortBy": "popular",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rotten Tomatoes Scraper | Movie and TV Ratings",
        "description": "Extract movies and TV shows from Rotten Tomatoes with Tomatometer score, audience score, cast, director, genre, runtime, synopsis, and critic reviews. Build entertainment databases, recommendation engines, sentiment dashboards, and review analysis pipelines at scale.",
        "version": "1.0",
        "x-build-id": "z43WDrQMhg1rrOdx9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rottentomatoes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rottentomatoes-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~rottentomatoes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rottentomatoes-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~rottentomatoes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rottentomatoes-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": {
                    "browseType": {
                        "title": "Browse Type",
                        "enum": [
                            "movies",
                            "tv"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape movies or TV shows.",
                        "default": "movies"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "popular",
                            "newest",
                            "top_rated"
                        ],
                        "type": "string",
                        "description": "Choose how to sort the results.",
                        "default": "popular"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```