# Metacritic Scraper (`cryptosignals/metacritic-scraper`) Actor

Scrape Metacritic reviews, scores, and ratings for games, movies, and TV shows. Extract critic scores, user scores, review text, and platform details. Track media reception and review trends. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/cryptosignals/metacritic-scraper.md
- **Developed by:** [CryptoSignals Agent](https://apify.com/cryptosignals) (community)
- **Categories:** News
- **Stats:** 3 total users, 1 monthly users, 88.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 result scrapeds

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/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 review scores, ratings, and metadata from [Metacritic](https://www.metacritic.com) — the web's leading review aggregation platform for **games, movies, TV shows, and music albums**.

### What It Does

This actor provides two powerful modes:

#### Search Mode
Search Metacritic's catalog by title across all categories or filter by games, movies, TV, or music. Returns structured data including Metascores, release dates, platforms, genres, and more.

#### Detail Mode
Extract comprehensive data from any Metacritic URL including:
- **Metascore** (critic aggregate) and **User Score**
- Full **critic reviews** with scores, quotes, and publication names
- Full **user reviews** with scores and comments
- Metadata: release date, platforms, genres, publisher, developer, content rating, description

### Use Cases

#### Gaming Data and Market Intelligence
Track review scores across the entire gaming landscape. Monitor how new releases perform critically, compare scores across platforms (PS5, Xbox, PC, Switch), and identify trends in game reception. Perfect for gaming journalists, YouTubers, and market analysts who need structured review data at scale.

#### Movie and TV Review Aggregation
Build dashboards that track critical reception of movies and TV shows. Compare Metascores against box office performance, identify critically acclaimed titles before they trend, or power recommendation engines with professional review data.

#### Sentiment Analysis and NLP Research
Access thousands of structured critic and user reviews with numeric scores. Use this data for sentiment analysis research, training NLP models on review text, or studying the correlation between professional and user sentiment across entertainment categories.

#### Competitive Intelligence for Publishers
Game publishers and movie studios can monitor how their titles compare against competitors. Track review trajectories over time, identify which reviewers tend to score higher or lower, and benchmark against industry averages.

#### Academic and Data Science Research
Study review score distributions across decades of entertainment. Analyze review inflation, platform bias, genre trends, and the relationship between critical and commercial success with clean, structured datasets.

#### Price and Value Analysis
Combine Metacritic scores with pricing data from other sources to calculate "value scores" — helping consumers find highly-rated titles at the best prices. Particularly useful for deal-hunting communities and budget gaming blogs.

#### Content Curation and Recommendation
Power content recommendation systems with professional review data. Build "best of" lists, curate genre-specific recommendations, or create personalized feeds based on user preferences aligned with critical consensus.

#### Portfolio and Catalog Management
Digital storefronts and subscription services can use review data to prioritize catalog acquisitions, optimize storefront placement, and identify underperforming titles that may need promotional support.

### Input Configuration

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `action` | string | `search` | `search` to find titles, `detail` to scrape a specific URL |
| `query` | string | — | Search term (required for search action) |
| `url` | string | — | Full Metacritic URL (required for detail action) |
| `category` | string | `all` | Filter: `all`, `games`, `movies`, `tv`, `music` |
| `maxItems` | integer | `20` | Max results to return (1-100, search only) |

### Example Inputs

#### Search for Games
```json
{
    "action": "search",
    "query": "zelda",
    "category": "games",
    "maxItems": 10
}
````

#### Search Across All Categories

```json
{
    "action": "search",
    "query": "inception",
    "category": "all",
    "maxItems": 20
}
```

#### Get Full Game Details

```json
{
    "action": "detail",
    "url": "https://www.metacritic.com/game/the-last-of-us/"
}
```

#### Get Movie Details with Reviews

```json
{
    "action": "detail",
    "url": "https://www.metacritic.com/movie/parasite/"
}
```

### Example Output

#### Search Result

```json
{
    "title": "The Legend of Zelda: Tears of the Kingdom",
    "type": "game-title",
    "url": "https://www.metacritic.com/game/the-legend-of-zelda-tears-of-the-kingdom/",
    "metascore": 96,
    "releaseDate": "2023-05-12",
    "description": "The sequel to The Legend of Zelda: Breath of the Wild...",
    "rating": "E10+",
    "platforms": ["Switch"],
    "genres": ["Adventure"],
    "image": "https://www.metacritic.com/a/img/resize/..."
}
```

#### Detail Result

```json
{
    "title": "The Last of Us",
    "url": "https://www.metacritic.com/game/the-last-of-us/",
    "metascore": 95,
    "userscore": 9.2,
    "reviewCount": 98,
    "description": "Twenty years after a pandemic...",
    "releaseDate": "2013-06-14",
    "contentRating": "M",
    "image": "https://www.metacritic.com/a/img/...",
    "platforms": ["PlayStation 3"],
    "genres": ["Linear Action Adventure"],
    "publisher": ["SCEA", "SCEI", "SCEE", "SCE Australia"],
    "developer": "Naughty Dog",
    "criticReviews": [
        {
            "score": 100,
            "author": "Eurogamer Italy",
            "quote": "Despite a few issues, The Last of Us represents...",
            "date": "Jun 5, 2013",
            "type": "critic"
        }
    ],
    "userReviews": [
        {
            "score": 10,
            "author": "LeonSKennedyyy",
            "quote": "A masterpiece of interactive storytelling...",
            "date": "Mar 15, 2024",
            "type": "user"
        }
    ]
}
```

### Supported Categories

| Category | URL Pattern | Examples |
|----------|-------------|----------|
| **Games** | `/game/slug/` | PS5, Xbox, PC, Switch titles |
| **Movies** | `/movie/slug/` | Theatrical and streaming releases |
| **TV Shows** | `/tv/slug/` | Series and seasons |
| **Music** | `/music/slug/` | Albums from all genres |

### Pay-Per-Result Pricing

This actor uses Apify's pay-per-result model:

| Event | Description |
|-------|-------------|
| `search-result` | Charged per search result returned |
| `detail-page` | Charged per detail page scraped |
| `review-extracted` | Charged per individual review extracted |

### Technical Details

- **HTTP-based scraping** using `httpx` with browser-like headers
- **JSON-LD extraction** from structured data embedded in pages
- **HTML parsing** via BeautifulSoup4 for scores, reviews, and metadata
- **Metacritic API** integration for fast, reliable search results
- **No browser required** — lightweight and fast execution
- Respects Metacritic's standard rate limiting
- Handles redirects and URL normalization automatically

### Integrations

Connect this actor with:

- **Google Sheets** — Export review data to spreadsheets automatically
- **Slack/Discord** — Get notifications when new reviews drop for tracked titles
- **Webhooks** — Trigger workflows when scores cross thresholds
- **API** — Access results programmatically via Apify API
- **Datasets** — Download results as JSON, CSV, or Excel

### Limitations

- Results depend on Metacritic's public data availability
- User reviews may be paginated; the actor extracts the first page of reviews
- Some older titles may have limited metadata
- Rate limiting applies to prevent overloading Metacritic's servers

### FAQ

**Q: How often is Metacritic data updated?**
A: Metacritic updates scores as new reviews are published. Run the actor on a schedule to track score changes over time.

**Q: Can I scrape all games/movies at once?**
A: Use the search action with broad queries and high maxItems, or combine multiple searches across categories. For bulk scraping, consider using Apify schedules.

**Q: What's the difference between Metascore and User Score?**
A: Metascore (0-100) is a weighted average of professional critic reviews. User Score (0-10) is an average of user-submitted ratings on Metacritic.

**Q: Does this work with Metacritic's new design?**
A: Yes, the actor is built for Metacritic's current Nuxt-based frontend and uses their backend API for search, ensuring compatibility with the latest site version.

### 🔒 Handling Metacritic Anti-Scraping

Metacritic (owned by Fandom) uses rate limiting and IP-based blocks to prevent automated access. Residential proxies help maintain reliable scraping sessions.

**[ThorData Residential Proxies](https://thordata.partnerstack.com/partner/0a0x4nzh)** offer 200M+ rotating residential IPs across 195 countries — ideal for scraping Metacritic scores and reviews without interruptions.

### Resources

- [Metacritic](https://www.metacritic.com) — Source website
- [Apify SDK for Python](https://docs.apify.com/sdk/python) — Actor development toolkit
- [Apify Platform](https://docs.apify.com/platform) — Run and schedule actors

# Actor input Schema

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

Choose whether to search for titles or get full details from a specific URL.

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

Search term to find titles on Metacritic (used with 'search' action). Alias: 'searchQuery'.

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

Full Metacritic URL to scrape details from (used with 'detail' action).

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

Filter search results by category. Alias: 'mediaType'. Maps: 'game'→'games'.

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

Maximum number of results to return (search mode only). Alias: 'maxResults'.

## Actor input object example

```json
{
  "action": "search",
  "query": "halo",
  "url": "https://www.metacritic.com/game/the-last-of-us/",
  "category": "all",
  "maxItems": 5
}
```

# 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 = {
    "action": "search",
    "query": "halo",
    "url": "https://www.metacritic.com/game/the-last-of-us/",
    "category": "all",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/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 = {
    "action": "search",
    "query": "halo",
    "url": "https://www.metacritic.com/game/the-last-of-us/",
    "category": "all",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/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 '{
  "action": "search",
  "query": "halo",
  "url": "https://www.metacritic.com/game/the-last-of-us/",
  "category": "all",
  "maxItems": 5
}' |
apify call cryptosignals/metacritic-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Metacritic Scraper",
        "description": "Scrape Metacritic reviews, scores, and ratings for games, movies, and TV shows. Extract critic scores, user scores, review text, and platform details. Track media reception and review trends. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "oe7BDougdKLm2HWNt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~metacritic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-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/cryptosignals~metacritic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-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/cryptosignals~metacritic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "Choose whether to search for titles or get full details from a specific URL.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find titles on Metacritic (used with 'search' action). Alias: 'searchQuery'.",
                        "default": "halo"
                    },
                    "url": {
                        "title": "Metacritic URL",
                        "type": "string",
                        "description": "Full Metacritic URL to scrape details from (used with 'detail' action)."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "games",
                            "movies",
                            "tv",
                            "music"
                        ],
                        "type": "string",
                        "description": "Filter search results by category. Alias: 'mediaType'. Maps: 'game'→'games'.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of results to return (search mode only). Alias: 'maxResults'.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```