# Metacritic Movie & TV Reviews Scraper (`crawlerbros/metacritic-scraper`) Actor

Scrape Metacritic search results, title pages, and browse listings for movies and TV shows, including Metascore, user score, synopsis, cast, and release metadata

- **URL**: https://apify.com/crawlerbros/metacritic-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 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

## Metacritic Scraper

Scrape Metacritic movies and TV shows by search query, slug, full URL, genre, year, or browse listing. The actor can return both lightweight list records and enriched detail records with Metascore, user score, synopsis, cast, and release metadata.

### Quick Start

1. Choose a mode such as `popular`, `search`, `byTitle`, or `byUrl`.
2. Pick `movie` or `tv`.
3. Keep `fetchDetail=true` if you want richer output fields.
4. Set `maxItems` to the smallest number you need for faster runs.

### Supported Modes

- `search`
- `byTitle`
- `byUrl`
- `byGenre`
- `byYear`
- `popular`
- `topRated`
- `trending`

### Typical Input

```json
{
  "platform": "metacritic",
  "mode": "popular",
  "mediaType": "movie",
  "fetchDetail": true,
  "maxItems": 10
}
````

### Example Search Input

```json
{
  "platform": "metacritic",
  "mode": "search",
  "mediaType": "movie",
  "searchQuery": "oppenheimer",
  "maxItems": 5
}
```

### Output

Depending on the mode and whether `fetchDetail` is enabled, records can include:

- Identity: `slug`, `url`, `title`, `mediaType`, `recordType`
- Ratings: `metascore`, `userScore`, `rating`
- Release fields: `releaseDate`, `year`
- Descriptive fields: `synopsis`, `genres`, `directors`, `cast`, `contentRating`
- Audit fields: `platform`, `scrapedAt`

Empty placeholder fields are omitted.

### Reliability Notes

- The actor prefers direct HTTP and automatically escalates to Apify proxy when Metacritic blocks with transient HTTP responses.
- Daily-test-friendly prefills use broad, positive-yield browse/search scenarios.
- `fetchDetail=true` gives the richest output and is recommended for production runs.

### FAQ

#### Does this actor scrape games or music?

No. This actor focuses on Metacritic movie and TV pages only.

#### Can I pass full Metacritic URLs?

Yes. Use `mode=byUrl` and provide movie or TV URLs.

#### Are empty or fake fallback records emitted?

No. The actor only emits records that were actually resolved from Metacritic.

# Actor input Schema

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

Fixed to Metacritic for this actor.

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

What to fetch from Metacritic.

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

Metacritic movie or TV pages.

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

Search term used when mode=search.

## `titles` (type: `array`):

Metacritic slugs (e.g. `oppenheimer`, `the-last-of-us`) or human-readable titles (e.g. `The Dark Knight`, `Breaking Bad`) when mode=byTitle. Human-readable titles are automatically converted to URL slugs.

## `urls` (type: `array`):

Full Metacritic movie/TV URLs when mode=byUrl.

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

Genre used for browse filters.

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

Release year used for mode=byYear or browse filtering.

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

Sort order for Metacritic browse pages. Results are sorted client-side from the fetched page — server-side sorting is not available for HTML pages.

## `fetchDetail` (type: `boolean`):

Follow each listing to its detail page to populate synopsis, cast, user score, and more.

## `minRating` (type: `number`):

Drop records below this Metascore.

## `maxRating` (type: `number`):

Drop records above this Metascore.

## `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 title.

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

Hard cap on emitted records.

## `autoEscalateOnBlock` (type: `boolean`):

Automatically engages Apify proxy when Metacritic blocks direct requests with 403/429.

## `proxyGroups` (type: `array`):

Proxy groups to use after a block. Empty uses the default escalation path.

## Actor input object example

```json
{
  "platform": "metacritic",
  "mode": "popular",
  "mediaType": "movie",
  "searchQuery": "oppenheimer",
  "titles": [],
  "urls": [],
  "mcBrowseSort": "metascore_desc",
  "fetchDetail": true,
  "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": "metacritic",
    "mode": "popular",
    "mediaType": "movie",
    "searchQuery": "oppenheimer",
    "titles": [],
    "urls": [],
    "mcBrowseSort": "metascore_desc",
    "fetchDetail": true,
    "maxItems": 10,
    "autoEscalateOnBlock": true,
    "proxyGroups": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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": "metacritic",
    "mode": "popular",
    "mediaType": "movie",
    "searchQuery": "oppenheimer",
    "titles": [],
    "urls": [],
    "mcBrowseSort": "metascore_desc",
    "fetchDetail": True,
    "maxItems": 10,
    "autoEscalateOnBlock": True,
    "proxyGroups": [],
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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": "metacritic",
  "mode": "popular",
  "mediaType": "movie",
  "searchQuery": "oppenheimer",
  "titles": [],
  "urls": [],
  "mcBrowseSort": "metascore_desc",
  "fetchDetail": true,
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}' |
apify call crawlerbros/metacritic-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Metacritic Movie & TV Reviews Scraper",
        "description": "Scrape Metacritic search results, title pages, and browse listings for movies and TV shows, including Metascore, user score, synopsis, cast, and release metadata",
        "version": "1.0",
        "x-build-id": "8wmQ9SGgUDWw3uqPi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~metacritic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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~metacritic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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~metacritic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": [
                            "metacritic"
                        ],
                        "type": "string",
                        "description": "Fixed to Metacritic for this actor.",
                        "default": "metacritic"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byTitle",
                            "byUrl",
                            "byGenre",
                            "byYear",
                            "popular",
                            "topRated",
                            "trending"
                        ],
                        "type": "string",
                        "description": "What to fetch from Metacritic.",
                        "default": "popular"
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "movie",
                            "tv"
                        ],
                        "type": "string",
                        "description": "Metacritic movie or TV pages.",
                        "default": "movie"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search term used when mode=search.",
                        "default": "oppenheimer"
                    },
                    "titles": {
                        "title": "Metacritic slugs or titles",
                        "type": "array",
                        "description": "Metacritic slugs (e.g. `oppenheimer`, `the-last-of-us`) or human-readable titles (e.g. `The Dark Knight`, `Breaking Bad`) when mode=byTitle. Human-readable titles are automatically converted to URL slugs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Metacritic URLs",
                        "type": "array",
                        "description": "Full Metacritic movie/TV URLs when mode=byUrl.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "genre": {
                        "title": "Genre",
                        "enum": [
                            "Action",
                            "Adventure",
                            "Animation",
                            "Biography",
                            "Comedy",
                            "Crime",
                            "Documentary",
                            "Drama",
                            "Fantasy",
                            "History",
                            "Horror",
                            "Music",
                            "Mystery",
                            "Romance",
                            "Science Fiction",
                            "Sport",
                            "Thriller",
                            "War",
                            "Western"
                        ],
                        "type": "string",
                        "description": "Genre used for browse filters."
                    },
                    "year": {
                        "title": "Year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Release year used for mode=byYear or browse filtering."
                    },
                    "mcBrowseSort": {
                        "title": "Browse sort",
                        "enum": [
                            "metascore_desc",
                            "metascore_asc",
                            "userscore_desc",
                            "releasedate_desc",
                            "releasedate_asc",
                            "alpha_asc"
                        ],
                        "type": "string",
                        "description": "Sort order for Metacritic browse pages. Results are sorted client-side from the fetched page — server-side sorting is not available for HTML pages.",
                        "default": "metascore_desc"
                    },
                    "fetchDetail": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Follow each listing to its detail page to populate synopsis, cast, user score, and more.",
                        "default": true
                    },
                    "minRating": {
                        "title": "Min Metascore",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop records below this Metascore."
                    },
                    "maxRating": {
                        "title": "Max Metascore",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop records above this Metascore."
                    },
                    "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 title."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 10
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to proxy on block",
                        "type": "boolean",
                        "description": "Automatically engages Apify proxy when Metacritic blocks direct requests with 403/429.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups",
                        "type": "array",
                        "description": "Proxy groups to use after a block. Empty uses the default escalation path.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
