# TMDB + Rotten Tomatoes + Metacritic Scraper (`crawlerbros/tmdb-rt-metacritic-scraper`) Actor

Unified movie/TV/person metadata from three sources. TMDB official API (search, popular, trending, discover, credits). Rotten Tomatoes (Tomatometer + Audience Score). Metacritic (Metascore + User Score). One actor, switch via the `platform` dropdown.

- **URL**: https://apify.com/crawlerbros/tmdb-rt-metacritic-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TMDB + Rotten Tomatoes + Metacritic Scraper

One actor, three sources of movie/TV/people metadata. Switch the source via the `platform` dropdown.

- **TMDB** — themoviedb.org official REST API. Requires a free API key. Search, lookup-by-ID, browse popular / top rated / upcoming / now-playing / trending, discover with filters, person filmography, and the full `append_to_response` toolkit (credits, videos, similar, recommendations, keywords, external IDs, alternative titles, translations).
- **Rotten Tomatoes** — server-rendered HTML scraping (no auth). Search, browse popular, browse upcoming / in-theaters / at-home, look up movie or TV detail by slug or URL. Returns Tomatometer, Audience Score, certified-fresh status, cast, directors, synopsis.
- **Metacritic** — server-rendered HTML scraping (no auth). Search, browse top scores, browse by year / genre / sort, look up movie or TV detail by slug or URL. Returns Metascore, User Score, synopsis, content rating, genres, cast, directors.

All three platforms emit a unified record shape: `platform`, `recordType`, `title`, `year`, `rating`, `url`, `mediaType` are always present (when available); platform-specific fields (`tomatometer`, `metascore`, `tmdbId`, etc.) live alongside.

### Quick Start

1. Pick a `platform` — `rottentomatoes` (no auth, default), `metacritic`
   (no auth), or `tmdb` (free API key required).
2. Pick a `mode` — `popular` is the easiest no-input run.
3. (TMDB only) paste a free API key from
   https://www.themoviedb.org/settings/api into `tmdbApiKey`.
4. Run. The default daily test (`platform=rottentomatoes, mode=popular,
   maxItems=10`) returns ~10 records with no auth and no proxy.

### Use cases

- Build a "best films of <year>" leaderboard combining all three rating systems.
- Cross-reference critic vs. audience scores for any title (TMDB vote, Tomatometer, Audience, Metascore, User Score).
- Pull a director's full TMDB filmography in a single run.
- Browse Metacritic's all-time top movies sorted by Metascore.
- Search any of the three platforms by free-text query and follow each result to its detail page for full metadata.

### Inputs

The schema is fully self-documenting in the Apify console. Highlights:

| Field | Required? | Description |
|---|---|---|
| `platform` | yes | `tmdb`, `rottentomatoes`, or `metacritic`. |
| `mode` | yes | `search`, `byTitle`, `byUrl`, `byPerson`, `byGenre`, `byYear`, `popular`, `topRated`, `trending`, `upcoming`, `nowPlaying`, `discover`. |
| `tmdbApiKey` | yes when `platform=tmdb` | Free API key from https://www.themoviedb.org/settings/api. |
| `searchQuery` | yes when `mode=search` | Free-text query. |
| `titles` | yes when `mode=byTitle` | TMDB IDs / RT slugs / MC slugs. |
| `urls` | yes when `mode=byUrl` | Full URLs. Auto-detects platform per URL. |
| `mediaType` | optional | `movie`, `tv`, `person`, `multi` (TMDB search only). |
| `genre` | optional | Dropdown — Action, Drama, Sci-Fi, etc. Maps to TMDB IDs; substring filter for RT/MC. |
| `year` / `yearMin` / `yearMax` | optional | Year filters. |
| `minRating` / `maxRating` | optional | Rating filters (TMDB 0-10, RT/MC 0-100). |
| `containsKeyword` | optional | Title substring filter. |
| `language` | optional | TMDB locale (`en-US`, `fr-FR`, ...). RT/MC English only. |
| `region` | optional | TMDB region code (`US`, `GB`, ...). |
| `sortBy` | optional | TMDB discover sort order. |
| `tmdbList` | optional | TMDB curated list when `mode=popular`/`topRated`/`upcoming`/`nowPlaying`. |
| `trendingWindow` | optional | TMDB trending window: `day` or `week`. |
| `rtBrowseList` | optional | RT browse listing (in theaters / at home / coming soon / TV series). |
| `mcBrowseSort` | optional | Metacritic browse sort. |
| `appendToResponse` | optional | TMDB `append_to_response` extras: credits, videos, images, reviews, similar, recommendations, keywords, release_dates, external_ids, alternative_titles, translations. |
| `fetchDetail` | optional, default `true` | Follow each list-item to the detail page for full metadata. |
| `maxItems` | optional, default `10` | Hard cap on emitted records. |
| `autoEscalateOnBlock` | optional, default `true` | Auto-engage Apify Proxy on RT/MC HTTP 403/429 blocks. |

### Output

Every record carries:

- `platform` — `tmdb`, `rottentomatoes`, or `metacritic`.
- `recordType` — `movie`, `tv`, or `person`.
- `mediaType` — same as `recordType` for media entries.
- `title` — display name.
- `year` — first release year (when available).
- `rating` — primary rating on each platform (TMDB vote_average 0-10, RT Tomatometer 0-100, MC Metascore 0-100).
- `url` — canonical URL on the platform.
- `scrapedAt` — ISO-8601 timestamp.

Platform-specific fields populate when present:

- **TMDB**: `tmdbId`, `voteCount`, `popularity`, `posterUrl`, `backdropUrl`, `genres` (names), `genreIds`, `cast`, `crew`, `videos`, `similar`, `recommendations`, `keywords`, `imdbId`, `tvdbId`, `runtime`, `tagline`, `status`, `homepage`, `budget`, `revenue`, `productionCompanies`, `spokenLanguages`, `numberOfSeasons`, `numberOfEpisodes`, `networks`, `createdBy`, `originalTitle`, `originalLanguage`, `overview`, `releaseDate`, `firstAirDate`, `lastAirDate`, `originCountry`, `inProduction`, `adult`, `biography`, `birthday`, `deathday`, `placeOfBirth`, `gender`, `alsoKnownAs`, `knownFor`, `knownForDepartment`.
- **Rotten Tomatoes**: `tomatometer`, `audienceScore`, `tomatometerCertified`, `tomatometerSentiment`, `audienceSentiment`, `criticsReviewCount`, `cast`, `directors`, `genres`, `synopsis`, `posterUrl`, `slug`, `endYear`, `datePublished`.
- **Metacritic**: `metascore`, `userScore`, `criticsReviewCount`, `cast`, `directors`, `genres`, `synopsis`, `contentRating`, `posterUrl`, `slug`, `releaseDate`.

### Modes per platform

| Mode | TMDB | Rotten Tomatoes | Metacritic |
|---|---|---|---|
| `search` | text query (movie / tv / person / multi) | text query | text query |
| `byTitle` | TMDB ID lookup | RT slug → detail | MC slug → detail |
| `byUrl` | TMDB URL → detail | RT URL → detail | MC URL → detail |
| `byPerson` | full filmography | (TMDB only) | (TMDB only) |
| `byGenre` | discover with `with_genres=ID` | browse + substring filter | browse with `genre=` |
| `byYear` | discover with `primary_release_year=Y` | browse + filter | browse with `releaseYearMin/Max=Y` |
| `popular` | `/movie/popular` or `/tv/popular` | `/browse/movies_at_home/sort:popular` | `/browse/movie/?sort=metascore_desc` |
| `topRated` | `/movie/top_rated` or `/tv/top_rated` | `/browse/.../sort:top_box_office` | `/browse/movie/?sort=metascore_desc` |
| `trending` | `/trending/{movie\|tv\|person}/{day\|week}` | `/browse/.../sort:popular` | `/browse/.../sort=userscore_desc` |
| `upcoming` | `/movie/upcoming` | `/browse/movies_coming_soon` | `/browse/.../sort=releasedate_desc` |
| `nowPlaying` | `/movie/now_playing` | `/browse/movies_in_theaters/sort:popular` | n/a |
| `discover` | `/discover/movie` or `/discover/tv` | (TMDB only) | (TMDB only) |

### How charging works

Charging is configured at the platform level (consumption pricing on Apify). The actor itself does not contain pricing logic — adjust on the Apify console.

### Limitations

- **TMDB requires a free API key** at https://www.themoviedb.org/settings/api. Without it, the actor emits a status message and 0 records — by design (TMDB's terms forbid sharing the actor author's key).
- **RT and MC are English-only** — they don't expose localized titles. If you set `language=fr-FR`, TMDB returns French titles; RT/MC ignore the setting.
- **RT pagination is single-page** for `popular` / browse listings (~50 items per fetch). MC supports `?page=N` (≤5 pages, ≈25 records each).
- **Some RT pages don't expose Audience Score** before opening night; the field is omitted (per the omit-empty rule).
- **MC `userScore`** is 0-10 (not 0-100 like Metascore). Both fields are emitted side-by-side when available.
- **Record types are flat** — `cast` is a list of strings on RT/MC but a list of `{name, character, tmdbId}` objects on TMDB. Filter / project accordingly downstream.
- **Daily test default**: `platform=rottentomatoes, mode=popular, maxItems=10`. This produces ≥1 record without any user-supplied secrets. For TMDB modes, set `tmdbApiKey` on the test page.
- **Robots / search paths**: rottentomatoes.com and metacritic.com `robots.txt` lists `/search` under `Disallow: *` (no `Crawl-delay`). The actor's `mode=search` only runs on explicit user-supplied queries (not bulk discovery) and paces requests at 0.25-0.3s. Detail / browse modes use unrestricted paths (`/m/`, `/tv/`, `/movie/`, `/browse/`). TMDB calls hit the official `api.themoviedb.org` REST endpoint under your own API key.

### FAQ

**Q: Can I cross-reference TMDB / RT / Metacritic scores in a single run?**
Run the actor 3 times (once per platform) with the same `searchQuery`, and join the datasets on `title` + `year` downstream.

**Q: How do I get TMDB credits in the same record as the movie?**
Set `mode=byTitle`, `platform=tmdb`, `appendToResponse=["credits"]`. The actor calls `/movie/{id}?append_to_response=credits` and flattens the cast into the record.

**Q: Why do some RT records lack `synopsis`?**
RT renders synopsis inside a `<drawer-more>` only on detail pages, not search/browse cards. With `fetchDetail=true` (default), the actor follows each card to the detail page; if the page layout differs (older titles), synopsis is omitted (per the omit-empty rule).

**Q: Why is `mode=byPerson` TMDB-only?**
RT and Metacritic do expose celebrity pages, but they don't list the full filmography programmatically (links scatter across separate "More Movies" / "More TV" sections). TMDB's `/person/{id}/movie_credits` endpoint cleanly returns the full credits list.

**Q: Why do some `discover` queries return 0 records?**
TMDB enforces a `vote_count.gte` floor; if you pair `vote_average.desc` with a low `minVoteCount`, you'll get obscure 10/10 titles. Bump `minVoteCount` to ~50 for "real" top titles.

**Q: What happens on RT/MC anti-bot blocks?**
The actor auto-escalates to Apify Proxy (datacenter → residential) on HTTP 403/429. Set `autoEscalateOnBlock=false` to disable.

# Actor input Schema

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

Which source to scrape.
## `mode` (type: `string`):

What to fetch. Available modes vary by platform — see README.
## `mediaType` (type: `string`):

Movie, TV show, person, or all (multi). Some modes only apply to one type — see README.
## `tmdbApiKey` (type: `string`):

Free TMDB v3 API key — sign up at https://www.themoviedb.org/settings/api. Leave empty if scraping Rotten Tomatoes or Metacritic only.
## `searchQuery` (type: `string`):

Free-text query. e.g. `oppenheimer`, `breaking bad`, `Christopher Nolan`.
## `titles` (type: `array`):

List of TMDB numeric IDs, RT slugs (`oppenheimer_2023`), or Metacritic slugs (`oppenheimer`). Mixed inputs work — the actor disambiguates by platform.
## `urls` (type: `array`):

Full URLs. Examples: `https://www.themoviedb.org/movie/872585`, `https://www.rottentomatoes.com/m/oppenheimer_2023`, `https://www.metacritic.com/movie/oppenheimer/`.
## `personId` (type: `string`):

TMDB person ID (e.g. `525`). Returns full filmography.
## `tmdbList` (type: `string`):

Which TMDB curated movie list to fetch (only when platform=tmdb).
## `trendingWindow` (type: `string`):

TMDB trending window — daily or weekly.
## `genre` (type: `string`):

Genre name. TMDB maps to numeric IDs; RT/MC apply substring filtering on the page.
## `year` (type: `integer`):

Primary release year (TMDB) / browse-by-year (RT, MC).
## `sortBy` (type: `string`):

Sort order. TMDB discover uses these values directly; RT/MC translate to their own sort options.
## `language` (type: `string`):

Two-letter ISO 639-1 language code, optionally with country (e.g. `en-US`, `fr-FR`). TMDB localises titles, overviews, and genre names. RT/MC are English-only.
## `region` (type: `string`):

Two-letter country code for region-specific release dates and certifications (TMDB).
## `minVoteCount` (type: `integer`):

Drop TMDB records with fewer votes than this. Useful for filtering out obscure / un-rated entries.
## `minRating` (type: `number`):

Drop records below this rating. TMDB: 0-10 (vote_average). RT: 0-100 (Tomatometer). MC: 0-100 (Metascore).
## `maxRating` (type: `number`):

Drop records above this rating (same scale as `minRating`).
## `yearMin` (type: `integer`):

Drop records released before this year.
## `yearMax` (type: `integer`):

Drop records released after this year.
## `containsKeyword` (type: `string`):

Case-insensitive substring filter on the title.
## `includeAdult` (type: `boolean`):

When true, TMDB includes adult titles in results. Default false.
## `rtBrowseList` (type: `string`):

Which RT browse listing to scrape.
## `mcBrowseSort` (type: `string`):

How to sort Metacritic browse listings.
## `fetchDetail` (type: `boolean`):

If true (default), the actor follows each list-item to its detail page to populate full metadata (synopsis, cast, full ratings). Disable for faster, lighter list-only output.
## `appendToResponse` (type: `array`):

TMDB extras to append to detail responses. Common: `credits`, `videos`, `images`, `reviews`, `similar`, `recommendations`, `keywords`, `release_dates`, `external_ids`.
## `maxItems` (type: `integer`):

Hard cap on emitted records.
## `autoEscalateOnBlock` (type: `boolean`):

When true (default), automatically engages Apify Proxy on HTTP 403/429 from RT or Metacritic. Has no effect on TMDB (no proxy needed for the official API).
## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.

## Actor input object example

```json
{
  "platform": "rottentomatoes",
  "mode": "popular",
  "mediaType": "movie",
  "searchQuery": "oppenheimer",
  "titles": [],
  "urls": [],
  "trendingWindow": "week",
  "sortBy": "popularity.desc",
  "language": "en-US",
  "includeAdult": false,
  "mcBrowseSort": "metascore_desc",
  "fetchDetail": true,
  "appendToResponse": [
    "credits"
  ],
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
````

# Actor output Schema

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

Dataset containing all scraped movies, TV shows, and people.

# 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 = {
    "platform": "rottentomatoes",
    "mode": "popular",
    "mediaType": "movie",
    "searchQuery": "oppenheimer",
    "trendingWindow": "week",
    "sortBy": "popularity.desc",
    "language": "en-US",
    "includeAdult": false,
    "mcBrowseSort": "metascore_desc",
    "fetchDetail": true,
    "maxItems": 10,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/tmdb-rt-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 = {
    "platform": "rottentomatoes",
    "mode": "popular",
    "mediaType": "movie",
    "searchQuery": "oppenheimer",
    "trendingWindow": "week",
    "sortBy": "popularity.desc",
    "language": "en-US",
    "includeAdult": False,
    "mcBrowseSort": "metascore_desc",
    "fetchDetail": True,
    "maxItems": 10,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/tmdb-rt-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 '{
  "platform": "rottentomatoes",
  "mode": "popular",
  "mediaType": "movie",
  "searchQuery": "oppenheimer",
  "trendingWindow": "week",
  "sortBy": "popularity.desc",
  "language": "en-US",
  "includeAdult": false,
  "mcBrowseSort": "metascore_desc",
  "fetchDetail": true,
  "maxItems": 10,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/tmdb-rt-metacritic-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TMDB + Rotten Tomatoes + Metacritic Scraper",
        "description": "Unified movie/TV/person metadata from three sources. TMDB official API (search, popular, trending, discover, credits). Rotten Tomatoes (Tomatometer + Audience Score). Metacritic (Metascore + User Score). One actor, switch via the `platform` dropdown.",
        "version": "1.0",
        "x-build-id": "YfRBPW2FCZotWXlVB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tmdb-rt-metacritic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-tmdb-rt-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/crawlerbros~tmdb-rt-metacritic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-tmdb-rt-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/crawlerbros~tmdb-rt-metacritic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-tmdb-rt-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",
                "required": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "tmdb",
                            "rottentomatoes",
                            "metacritic"
                        ],
                        "type": "string",
                        "description": "Which source to scrape.",
                        "default": "rottentomatoes"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byTitle",
                            "byUrl",
                            "byPerson",
                            "byGenre",
                            "byYear",
                            "popular",
                            "topRated",
                            "trending",
                            "upcoming",
                            "nowPlaying",
                            "discover"
                        ],
                        "type": "string",
                        "description": "What to fetch. Available modes vary by platform — see README.",
                        "default": "popular"
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "movie",
                            "tv",
                            "person",
                            "multi"
                        ],
                        "type": "string",
                        "description": "Movie, TV show, person, or all (multi). Some modes only apply to one type — see README.",
                        "default": "movie"
                    },
                    "tmdbApiKey": {
                        "title": "TMDB API key (required when platform=tmdb)",
                        "type": "string",
                        "description": "Free TMDB v3 API key — sign up at https://www.themoviedb.org/settings/api. Leave empty if scraping Rotten Tomatoes or Metacritic only."
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query. e.g. `oppenheimer`, `breaking bad`, `Christopher Nolan`.",
                        "default": "oppenheimer"
                    },
                    "titles": {
                        "title": "Titles / IDs / slugs (mode=byTitle)",
                        "type": "array",
                        "description": "List of TMDB numeric IDs, RT slugs (`oppenheimer_2023`), or Metacritic slugs (`oppenheimer`). Mixed inputs work — the actor disambiguates by platform.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Full URLs. Examples: `https://www.themoviedb.org/movie/872585`, `https://www.rottentomatoes.com/m/oppenheimer_2023`, `https://www.metacritic.com/movie/oppenheimer/`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "personId": {
                        "title": "Person ID (mode=byPerson, TMDB only)",
                        "type": "string",
                        "description": "TMDB person ID (e.g. `525`). Returns full filmography."
                    },
                    "tmdbList": {
                        "title": "TMDB curated list (mode=popular/topRated/upcoming/nowPlaying)",
                        "enum": [
                            "popular",
                            "top_rated",
                            "upcoming",
                            "now_playing",
                            "airing_today",
                            "on_the_air"
                        ],
                        "type": "string",
                        "description": "Which TMDB curated movie list to fetch (only when platform=tmdb)."
                    },
                    "trendingWindow": {
                        "title": "Trending time window (mode=trending, TMDB)",
                        "enum": [
                            "day",
                            "week"
                        ],
                        "type": "string",
                        "description": "TMDB trending window — daily or weekly.",
                        "default": "week"
                    },
                    "genre": {
                        "title": "Genre (mode=byGenre / discover)",
                        "enum": [
                            "Action",
                            "Adventure",
                            "Animation",
                            "Anime",
                            "Biography",
                            "Comedy",
                            "Crime",
                            "Documentary",
                            "Drama",
                            "Family",
                            "Fantasy",
                            "History",
                            "Horror",
                            "Kids",
                            "Music",
                            "Musical",
                            "Mystery",
                            "News",
                            "Reality",
                            "Romance",
                            "Science Fiction",
                            "Soap",
                            "Sport",
                            "Talk",
                            "Thriller",
                            "TV Movie",
                            "War",
                            "War & Politics",
                            "Western"
                        ],
                        "type": "string",
                        "description": "Genre name. TMDB maps to numeric IDs; RT/MC apply substring filtering on the page."
                    },
                    "year": {
                        "title": "Year (mode=byYear / discover)",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Primary release year (TMDB) / browse-by-year (RT, MC)."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "popularity.desc",
                            "popularity.asc",
                            "vote_average.desc",
                            "vote_average.asc",
                            "primary_release_date.desc",
                            "primary_release_date.asc",
                            "first_air_date.desc",
                            "first_air_date.asc",
                            "revenue.desc",
                            "vote_count.desc"
                        ],
                        "type": "string",
                        "description": "Sort order. TMDB discover uses these values directly; RT/MC translate to their own sort options.",
                        "default": "popularity.desc"
                    },
                    "language": {
                        "title": "Language (TMDB `language` param)",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "es-ES",
                            "es-MX",
                            "fr-FR",
                            "de-DE",
                            "it-IT",
                            "pt-BR",
                            "pt-PT",
                            "ja-JP",
                            "ko-KR",
                            "zh-CN",
                            "zh-TW",
                            "ru-RU",
                            "ar-SA",
                            "hi-IN",
                            "tr-TR",
                            "nl-NL",
                            "pl-PL",
                            "sv-SE",
                            "da-DK",
                            "fi-FI",
                            "no-NO",
                            "el-GR",
                            "he-IL",
                            "th-TH",
                            "id-ID",
                            "vi-VN",
                            "uk-UA",
                            "cs-CZ",
                            "hu-HU",
                            "ro-RO",
                            "bg-BG"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO 639-1 language code, optionally with country (e.g. `en-US`, `fr-FR`). TMDB localises titles, overviews, and genre names. RT/MC are English-only.",
                        "default": "en-US"
                    },
                    "region": {
                        "title": "Region (TMDB `region` ISO-3166)",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "JP",
                            "KR",
                            "CN",
                            "BR",
                            "MX",
                            "IN",
                            "RU",
                            "TR",
                            "NL",
                            "SE",
                            "PL",
                            "AR"
                        ],
                        "type": "string",
                        "description": "Two-letter country code for region-specific release dates and certifications (TMDB)."
                    },
                    "minVoteCount": {
                        "title": "Min vote count (TMDB filter)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop TMDB records with fewer votes than this. Useful for filtering out obscure / un-rated entries."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop records below this rating. TMDB: 0-10 (vote_average). RT: 0-100 (Tomatometer). MC: 0-100 (Metascore)."
                    },
                    "maxRating": {
                        "title": "Max rating",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop records above this rating (same scale as `minRating`)."
                    },
                    "yearMin": {
                        "title": "Min year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop records released before this year."
                    },
                    "yearMax": {
                        "title": "Max year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop records released after this year."
                    },
                    "containsKeyword": {
                        "title": "Title contains",
                        "type": "string",
                        "description": "Case-insensitive substring filter on the title."
                    },
                    "includeAdult": {
                        "title": "Include adult content (TMDB)",
                        "type": "boolean",
                        "description": "When true, TMDB includes adult titles in results. Default false.",
                        "default": false
                    },
                    "rtBrowseList": {
                        "title": "Rotten Tomatoes browse list (RT popular/topRated/upcoming/nowPlaying)",
                        "enum": [
                            "movies_in_theaters",
                            "movies_at_home",
                            "movies_coming_soon",
                            "tv_series_browse",
                            "movies_at_home/sort:popular",
                            "movies_at_home/sort:top_box_office",
                            "movies_at_home/sort:newest"
                        ],
                        "type": "string",
                        "description": "Which RT browse listing to scrape."
                    },
                    "mcBrowseSort": {
                        "title": "Metacritic browse sort",
                        "enum": [
                            "metascore_desc",
                            "metascore_asc",
                            "userscore_desc",
                            "releasedate_desc",
                            "releasedate_asc",
                            "alpha_asc"
                        ],
                        "type": "string",
                        "description": "How to sort Metacritic browse listings.",
                        "default": "metascore_desc"
                    },
                    "fetchDetail": {
                        "title": "Fetch full detail page",
                        "type": "boolean",
                        "description": "If true (default), the actor follows each list-item to its detail page to populate full metadata (synopsis, cast, full ratings). Disable for faster, lighter list-only output.",
                        "default": true
                    },
                    "appendToResponse": {
                        "title": "TMDB append_to_response (mode=byTitle / popular / topRated)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "TMDB extras to append to detail responses. Common: `credits`, `videos`, `images`, `reviews`, `similar`, `recommendations`, `keywords`, `release_dates`, `external_ids`.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "credits",
                                "videos",
                                "images",
                                "reviews",
                                "similar",
                                "recommendations",
                                "keywords",
                                "release_dates",
                                "external_ids",
                                "alternative_titles",
                                "translations"
                            ],
                            "enumTitles": [
                                "Cast & crew",
                                "Videos / trailers",
                                "Images / posters",
                                "Reviews",
                                "Similar titles",
                                "Recommendations",
                                "Keywords",
                                "Release dates per region",
                                "External IDs (IMDb/TVDB/...)",
                                "Alternative titles",
                                "Translations"
                            ]
                        },
                        "default": [
                            "credits"
                        ]
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 10
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on HTTP block",
                        "type": "boolean",
                        "description": "When true (default), automatically engages Apify Proxy on HTTP 403/429 from RT or Metacritic. Has no effect on TMDB (no proxy needed for the official API).",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
