# Metacritic Scraper — Metascores, user scores & reviews (`istmobot/metacritic-scraper`) Actor

Scrape Metacritic games, movies and TV shows: Metascore, user score, review counts and sentiment, release date, platforms, genres, developer, publisher and age rating, plus critic and user reviews. Browse with filters or pass title URLs. No API key needed.

- **URL**: https://apify.com/istmobot/metacritic-scraper.md
- **Developed by:** [Istmobot](https://apify.com/istmobot) (community)
- **Categories:** News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Metacritic Scraper: Metascores, User Scores & Reviews API

Scrape **Metacritic** data for **games, movies and TV shows**: Metascore, user score, review counts and sentiment, release date, platforms, genres, developer, publisher, plus **critic reviews** and **user reviews**. Use this Metacritic scraper as an unofficial **Metacritic API**: browse the catalog with filters or scrape the exact titles you need, then export the data to JSON, CSV or Excel.

### What is Metacritic Scraper?

Metacritic Scraper is an Apify Actor that pulls structured review-score data from [metacritic.com](https://www.metacritic.com). Metacritic has no public API, so this Actor works as a ready-made **Metacritic API alternative**. It reads the same JSON backend the metacritic.com website uses, so it needs **no browser, no login and no API key**.

- **Browse mode** works like metacritic.com/browse. Pick games, movies or TV and sort by Metascore, user score or release date. Filter by release year range, genres and (for games) platforms.
- **Titles mode** takes metacritic.com URLs (`/game/…`, `/movie/…`, `/tv/…`) or slugs. Add `?platform=pc` to a game URL to get that platform's Metascore, user score and reviews.
- **Platform-aware scores.** Metacritic scores each game platform separately. When you filter by platform, or pass `?platform=` in a URL, the scores and reviews you get are for that platform.
- **Critic and user reviews** can be nested inside each title, up to a cap you set per review type.
- **Robust.** Rate limits (HTTP 429) and server errors are retried with exponential backoff. A bad URL or missing title produces an error item and the run keeps going.

Download the dataset as JSON, CSV, Excel, HTML, XML or RSS, or fetch it through the Apify API.

#### What data can I extract with Metacritic Scraper?

| Field | Description |
|---|---|
| `title`, `slug`, `url` | Title name, Metacritic slug and canonical page URL |
| `productType` | `games`, `movies` or `tv` |
| `metaScore` | Critic Metascore (0–100) |
| `metaScoreReviewCount`, `metaScoreSentiment` | Number of critic reviews and their sentiment label (e.g. "Universal acclaim") |
| `userScore` | User score (0–10) |
| `userScoreReviewCount`, `userScoreSentiment` | Number of user ratings and their sentiment label |
| `platform` | Platform the scores refer to (games) |
| `platforms` | Every platform with its own Metascore and critic review count |
| `releaseDate` | Release date (YYYY-MM-DD) |
| `genres` | Metacritic genres |
| `developer`, `publisher` | Developer and publisher (games) |
| `rating` | Age rating (e.g. "M") |
| `description` | Summary text |
| `image` | Cover image URL |
| `reviews` | Optional critic and user reviews: author or publication, score, quote, date, link, platform, spoiler flag |
| `scrapedAt` | Timestamp of the scrape |

### How can I use Metacritic data?

- **Game studios and publishers**: track review scores and sentiment for your launches and your competitors', per platform.
- **Market research**: see which genres and platforms score best, year over year.
- **Recommendation systems and data science**: build training data from scores, genres and review text.
- **Journalists and content creators**: build lists like "best games of 2025 on Switch" or top horror films by user score.
- **Review monitoring**: schedule daily runs on your titles to pull the newest user reviews.

### How to scrape Metacritic data

1. Click **Try for free** to open Metacritic Scraper in Apify Console. A free Apify account is enough.
2. Choose a **Mode**. Use **Browse** with product type, sort order, year range, genres and platforms, or **Specific titles** with Metacritic URLs or slugs.
3. Optionally turn on **critic reviews** and/or **user reviews** and set **Max reviews per title**.
4. Set **Max titles** and click **Start**.
5. When the run finishes, open the **Output** tab and download the dataset as JSON, CSV, Excel or HTML, or read it via the API.

### How much does it cost to scrape Metacritic?

Metacritic Scraper uses **pay-per-event** pricing, so you only pay for the titles you get:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| `title-result` | $0.002 per title ($2 per 1,000 titles) |

**Critic and user reviews nested in a title are included in the title price.** They are not charged separately.

**Example:** 1 run that scrapes 1,000 titles costs $0.005 + 1,000 × $0.002 = **$2.005**.

The Apify **free plan includes $5 of monthly credit**, which covers about **2,500 titles** a month. You can set a **maximum cost per run**: when the limit is reached, the Actor stops cleanly and keeps everything scraped so far. **Error items are never charged.**

### ⬇️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | `browse` | `titles` | `browse` | Browse the catalog, or scrape specific titles |
| `productType` | `games` | `movies` | `tv` | `games` | What to browse (also the type used for bare slugs) |
| `sortBy` | string | `-metaScore` | `-metaScore`, `-userScore`, `-releaseDate` (newest), `releaseDate` (oldest) |
| `yearFrom` / `yearTo` | integer | — | Release year range (1900–2100) |
| `genres` | list of strings | — | Metacritic genre names, e.g. `Action RPG`, `JRPG`, `Horror`, `Drama` |
| `platforms` | list of strings | — | Games only: `PC`, `PS5`, `PS4`, `Xbox Series X`, `Xbox One`, `Nintendo Switch`, `Nintendo Switch 2`, `Mobile`, `Meta Quest`, retro consoles… |
| `startUrls` | list of URLs | — | Titles mode: metacritic.com title URLs |
| `slugs` | list of strings | — | Titles mode: slugs like `baldurs-gate-3` |
| `includeCriticReviews` | boolean | `false` | Add critic reviews |
| `includeUserReviews` | boolean | `false` | Add user reviews |
| `maxReviewsPerTitle` | integer | `20` | Cap per review type (critic and user each), up to 10,000 |
| `maxItems` | integer | `100` | Max titles in the output |

Browse example: top PC games released 2023–2025, with 10 critic reviews each.

```json
{
  "mode": "browse",
  "productType": "games",
  "sortBy": "-metaScore",
  "yearFrom": 2023,
  "yearTo": 2025,
  "platforms": ["PC"],
  "includeCriticReviews": true,
  "maxReviewsPerTitle": 10,
  "maxItems": 100
}
```

Titles example:

```json
{
  "mode": "titles",
  "startUrls": [
    "https://www.metacritic.com/game/elden-ring/",
    "https://www.metacritic.com/game/elden-ring/critic-reviews/?platform=pc",
    "https://www.metacritic.com/movie/the-godfather/",
    "https://www.metacritic.com/tv/breaking-bad/"
  ],
  "includeUserReviews": true,
  "maxReviewsPerTitle": 50
}
```

### ⬆️ Output

The Actor outputs one item per title. The **Overview** table view in the Output tab shows the cover, title, type, platform, Metascore, user score, review counts, release date, genres, developer and URL. The full item looks like this:

```json
{
  "title": "Elden Ring",
  "slug": "elden-ring",
  "url": "https://www.metacritic.com/game/elden-ring/",
  "productType": "games",
  "platform": "PC",
  "metaScore": 94,
  "metaScoreReviewCount": 60,
  "metaScoreSentiment": "Universal acclaim",
  "userScore": 7.6,
  "userScoreReviewCount": 6895,
  "userScoreSentiment": "Generally favorable",
  "releaseDate": "2022-02-25",
  "platforms": [
    { "name": "PC", "slug": "pc", "metaScore": 94, "reviewCount": 63 },
    { "name": "PlayStation 5", "slug": "playstation-5", "metaScore": 96, "reviewCount": 93 }
  ],
  "genres": ["Action RPG"],
  "developer": "From Software",
  "publisher": "Bandai Namco Games, From Software",
  "rating": "M",
  "description": "A New World Created By Hidetaka Miyazaki And George R. R. Martin…",
  "image": "https://www.metacritic.com/a/img/catalog/provider/6/12/6-1-824956-52.jpg",
  "reviews": [
    {
      "type": "critic",
      "author": null,
      "publication": "Areajugones",
      "score": 100,
      "quote": "Elden Ring is the real next step for souls-like standards…",
      "date": "2022-02-23",
      "url": "https://areajugones.sport.es/videojuegos/analisis-elden-ring-la-mesa-redonda-tiene-nuevo-rey-arturo/",
      "platform": "PC"
    },
    {
      "type": "user",
      "author": "MaleProtagonist",
      "publication": null,
      "score": 9,
      "quote": "Liked it better than Dark Souls 3…",
      "date": "2026-09-30",
      "url": null,
      "platform": "PC",
      "spoiler": false
    }
  ],
  "scrapedAt": "2026-10-01T01:38:56.434Z"
}
```

- `metaScore` ranges from 0 to 100 and `userScore` from 0 to 10. Both are `null` when Metacritic has not published a score yet (too few reviews).
- `platform` is the platform the scores refer to (games only). Without a platform filter it is Metacritic's default ("lead") platform for the title. `platforms[]` lists every platform with its own Metascore.
- `developer` and `publisher` are filled for games. Movies and TV have `null` there.
- `reviews` is present only when a review option is on.

#### Error items

When a title can't be scraped, the Actor outputs an error item instead of failing the run:

```json
{ "url": "https://www.metacritic.com/game/this-game-does-not-exist/", "slug": "this-game-does-not-exist", "productType": "games", "errorType": "NOT_FOUND", "error": "Title not found (no product data in page response)" }
```

`errorType` is `NOT_FOUND`, `FETCH_FAILED`, `INVALID_INPUT` or `BROWSE_FAILED`. Error items are never charged.

### Integrations and API

You can run Metacritic Scraper and read its results programmatically through the [Apify API](https://docs.apify.com/api/v2). The Actor ID is `istmobot/metacritic-scraper`.

**Python** ([apify-client](https://docs.apify.com/api/client/python)):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("istmobot/metacritic-scraper").call(run_input={
    "mode": "titles",
    "startUrls": ["https://www.metacritic.com/game/elden-ring/"],
    "includeCriticReviews": True,
    "maxReviewsPerTitle": 10,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item.get("metaScore"), item.get("userScore"))
```

**Node.js** ([apify-client](https://docs.apify.com/api/client/js)):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('istmobot/metacritic-scraper').call({
    mode: 'browse',
    productType: 'movies',
    sortBy: '-userScore',
    genres: ['Horror'],
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

You can also:

- **Schedule** runs (daily, weekly, or any cron expression) to track Metacritic scores and new reviews over time.
- Use **webhooks** to get notified or trigger your own pipeline when a run finishes.
- Connect the Actor to **Make, Zapier, n8n**, Google Sheets, Slack and other tools through Apify integrations.
- Use it from **AI agents** through the [Apify MCP server](https://mcp.apify.com).

### FAQ

**Is it legal to scrape Metacritic?**
This Actor only reads publicly visible data. It does not log in, and it collects no personal data beyond public review usernames. Review text and usernames can still count as personal data under GDPR and similar laws, so only collect what you need and have a legitimate reason for it. You are responsible for using the data in line with applicable laws and Metacritic's terms of use. If you're unsure, consult a lawyer.

This is an **unofficial** tool. It is not affiliated with, endorsed by or connected to Metacritic or Fandom, Inc.

**Do I need a Metacritic API key or account?**
No. The Actor reads the same public JSON data the metacritic.com website loads, without logging in.

**Which genre names can I use?**
Use the exact names Metacritic shows in its browse page filters. For games, that includes `Action RPG`, `JRPG`, `Western RPG`, `Open-World Action`, `3D Platformer`, `Survival` and `Roguelike`. For movies and TV, it includes `Action`, `Comedy`, `Drama`, `Horror`, `Thriller` and `Documentary`. If you list several genres, a title matches when it has any of them.

**Why does the Metascore differ from the one on the title's main page?**
Metacritic scores every game platform separately. With a platform filter (browse mode) or `?platform=` (in a URL), you get that platform's numbers. Otherwise you get the default platform, the same one shown on the main page.

**How many reviews can I get?**
Up to 10,000 per review type per title. Critic reviews arrive in pages of 10 and user reviews in pages of 50, so large caps on popular titles (thousands of user reviews) take longer.

**How fast is it?**
The Actor makes a few lightweight JSON requests per title and processes 3 titles in parallel. Browse results are fetched in pages of 50 titles. Turning on reviews adds requests for each title.

**Can I scrape TV seasons?**
Season URLs are accepted, but they resolve to the show. Season-level scores are not extracted yet.

**Do I need proxies?**
Usually not. The Actor backs off and retries automatically when Metacritic rate-limits requests.

**Can I schedule it?**
Yes. Create a schedule in Apify Console (or via the API) to run the Actor daily or weekly, for example to monitor new user reviews for your titles.

### Other Actors you might like

- [Steam Game Intelligence](https://apify.com/istmobot/steam-game-intelligence)
- [Earnings Call Transcripts Scraper](https://apify.com/istmobot/earnings-call-transcripts-scraper)
- [Zacks Rank Scraper](https://apify.com/istmobot/zacks-rank-scraper)
- [BoardGameGeek Scraper](https://apify.com/istmobot/boardgamegeek-scraper)

### Your feedback

Found a bug or need a field that's missing? Open an issue in the **Issues** tab and we'll take a look.

# Actor input Schema

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

"browse": list titles from Metacritic's catalog using the filters below (like metacritic.com/browse). "titles": scrape specific titles from URLs or slugs.

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

What to browse. In "titles" mode this is only used for bare slugs (URLs carry their own type).

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

Browse order. Sorting by Metascore only returns titles that have a Metascore.

## `yearFrom` (type: `integer`):

Only titles released in or after this year.

## `yearTo` (type: `integer`):

Only titles released in or before this year.

## `genres` (type: `array`):

Metacritic genre names exactly as shown on the site, e.g. games: "Action RPG", "JRPG", "Open-World Action", "3D Platformer"; movies/TV: "Horror", "Drama", "Comedy", "Documentary". A title matches if it has any of them.

## `platforms` (type: `array`):

e.g. "PC", "PS5", "PS4", "Xbox Series X", "Xbox One", "Nintendo Switch", "Nintendo Switch 2", "Mobile", "Meta Quest" — plus retro: PS1/PS2/PS3, Xbox 360, Wii, Wii U, 3DS, DS, GameCube, N64, Dreamcast.

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

Title pages for "titles" mode, e.g. https://www.metacritic.com/game/elden-ring/ or https://www.metacritic.com/movie/the-godfather/. Add ?platform=pc to a game URL to get that platform's scores and reviews.

## `slugs` (type: `array`):

Alternative to URLs: the slug from the URL (e.g. "baldurs-gate-3"). Interpreted with the product type above.

## `includeCriticReviews` (type: `boolean`):

Add critic reviews (publication, score, quote, link) to each title.

## `includeUserReviews` (type: `boolean`):

Add user reviews (username, score, text, date) to each title.

## `maxReviewsPerTitle` (type: `integer`):

Cap for critic reviews and for user reviews, each. Popular titles have thousands of user reviews.

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

Stop after this many titles.

## Actor input object example

```json
{
  "mode": "browse",
  "productType": "games",
  "sortBy": "-metaScore",
  "yearFrom": 2023,
  "yearTo": 2025,
  "startUrls": [
    "https://www.metacritic.com/game/elden-ring/",
    "https://www.metacritic.com/movie/the-godfather/",
    "https://www.metacritic.com/tv/breaking-bad/"
  ],
  "includeCriticReviews": false,
  "includeUserReviews": false,
  "maxReviewsPerTitle": 10,
  "maxItems": 20
}
```

# 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 = {
    "mode": "browse",
    "productType": "games",
    "yearFrom": 2023,
    "yearTo": 2025,
    "startUrls": [
        "https://www.metacritic.com/game/elden-ring/",
        "https://www.metacritic.com/movie/the-godfather/",
        "https://www.metacritic.com/tv/breaking-bad/"
    ],
    "maxReviewsPerTitle": 10,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("istmobot/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 = {
    "mode": "browse",
    "productType": "games",
    "yearFrom": 2023,
    "yearTo": 2025,
    "startUrls": [
        "https://www.metacritic.com/game/elden-ring/",
        "https://www.metacritic.com/movie/the-godfather/",
        "https://www.metacritic.com/tv/breaking-bad/",
    ],
    "maxReviewsPerTitle": 10,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("istmobot/metacritic-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "browse",
  "productType": "games",
  "yearFrom": 2023,
  "yearTo": 2025,
  "startUrls": [
    "https://www.metacritic.com/game/elden-ring/",
    "https://www.metacritic.com/movie/the-godfather/",
    "https://www.metacritic.com/tv/breaking-bad/"
  ],
  "maxReviewsPerTitle": 10,
  "maxItems": 20
}' |
apify call istmobot/metacritic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,istmobot/metacritic-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BRTrJFxHV1t6nlA5D/builds/qcglcnm9FGzUJBgZQ/openapi.json