How to Scrape Metacritic in 2026 (API & Python)

The fastest way to scrape Metacritic in 2026 is to call a structured API that returns normalized JSON — title detail, Metascore, user score, and critic/user review text — for games, movies, and TV in the same request shape, instead of parsing Metacritic's Nuxt.js-rendered pages yourself. Metacritic is the reference aggregator for "is this any good" across three separate media types, but it has no self-serve public API, and its owner's terms explicitly restrict automated collection. This guide covers all three approaches, what each returns, where each breaks, and the legal reality up front.

Why scrape Metacritic?

Metacritic's Metascore and User Score anchor a lot of reception research, which powers:

• Cross-vertical rating aggregation — pull comparable critic/audience scores for games, movies, and TV from one source instead of three separate sites.
• Critic vs. audience sentiment analysis — compare a title's Metascore (critic consensus) against its User Score (audience consensus) to spot the gap between press and player/viewer reaction.
• Release and genre browse monitoring — track new releases by genre and content type as they land and get scored.
• Studio and franchise performance tracking — follow a publisher's or studio's Metascore trend across a catalog over time.
• Enrichment for media catalogs — attach Metascore and user-score fields to a game library, watchlist, or internal dataset, then pair with where a title is actually streaming for a full "is it good, and can I watch it" pipeline.

Is it legal to scrape Metacritic?

Option 1: DIY in Python (and why it breaks)

Metacritic runs on Nuxt.js (Vue), not the React/Next.js stack you'd expect from a lot of media sites, so a DIY scraper has to work around a window.__NUXT__ payload plus whatever JSON-LD schema.org markup happens to be embedded:

import requests
from bs4 import BeautifulSoup

resp = requests.get(
    "https://www.metacritic.com/game/elden-ring/",
    headers={"User-Agent": "Mozilla/5.0 (compatible; research-bot/1.0)"},
)
soup = BeautifulSoup(resp.text, "html.parser")
# The page also embeds a <script type="application/ld+json"> block with an
# aggregateRating (Metascore only — no User Score, no individual reviews)

It demos and then breaks:

• The ToS names scraping directly, and enforcement risk is real. Fandom's Terms of Use call out "spidering," "scraping," and "data mining" by name, plus a separate AI/ML-training restriction — this isn't an implied restriction you're inferring from silence.
• The JSON-LD block is incomplete. The embedded AggregateRating schema gives you the Metascore and review count, but not the User Score, individual critic/user reviews, platform breakdowns, or genre tags — you'd still have to parse the full __NUXT__ payload for the rest, and that payload's shape isn't documented and shifts with releases.
• Three separate content types, three separate page shapes. Game pages carry platform breakdowns; movie and TV pages carry different fields (season count, networks, IMDb cross-reference) — one parser rarely covers all three cleanly.
• Reviews paginate separately. Critic reviews and user reviews each live on their own sub-page per title, so a full title record means multiple page loads, not one.

Option 2: No-code tools

There's no equivalent to IMDb's non-commercial datasets file here — Metacritic doesn't publish a bulk data download. Marketplace scraper actors exist for one-off Metacritic pulls, but they carry the same ToS exposure as DIY and are awkward to run on a schedule inside a pipeline. The one B2B-licensed alternative, Fabric Origin's Metacritic API, requires a paid subscription and developer approval, and only covers movies and TV shows — not games.

Option 3: A structured Metacritic API

For a repeatable workflow that covers all three verticals, a Metacritic scraping API returns normalized JSON with no page parsing to maintain. Browse by content type and genre to find titles:

curl "https://api.crawlora.net/api/v1/metacritic/browse?type=game&genre=Action%20RPG&sort=score" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{
  "code": 200,
  "msg": "OK",
  "data": {
    "type": "game",
    "sort": "score",
    "total": 500,
    "page": 1,
    "per_page": 24,
    "items": [
      {
        "id": 1,
        "type": "game",
        "title": "The Legend of Zelda: Ocarina of Time (1998)",
        "slug": "the-legend-of-zelda-ocarina-of-time-1998",
        "url": "https://www.metacritic.com/game/the-legend-of-zelda-ocarina-of-time-1998/",
        "premiere_year": 1998,
        "rating": "E",
        "metascore": { "score": 99, "max": 100, "sentiment": "Universal acclaim" },
        "user_score": 9.1,
        "genres": [{ "name": "Adventure" }]
      }
    ]
  }
}

Then pull a game by slug in Python:

import requests
h = {"x-api-key": "YOUR_API_KEY"}
base = "https://api.crawlora.net/api/v1/metacritic"

game = requests.get(f"{base}/game/elden-ring", headers=h).json()["data"]
critic_reviews = requests.get(f"{base}/game/elden-ring/critic-reviews", headers=h, params={"per_page": 20}).json()["data"]
user_reviews = requests.get(f"{base}/game/elden-ring/user-reviews", headers=h, params={"per_page": 20}).json()["data"]

Game detail returns Metascore and User Score as separate objects, plus a per-platform breakdown:

{
  "code": 200,
  "msg": "OK",
  "data": {
    "id": 123,
    "type": "game",
    "title": "Elden Ring",
    "slug": "elden-ring",
    "premiere_year": 2022,
    "release_date": "2022-02-25",
    "rating": "M",
    "metascore": {
      "score": 96,
      "max": 100,
      "review_count": 93,
      "positive_count": 86,
      "sentiment": "Universal acclaim",
      "url": "https://www.metacritic.com/game/elden-ring/critic-reviews/"
    },
    "user_score": { "score": 8.4, "max": 10, "review_count": 23997, "sentiment": "Generally favorable" },
    "genres": [{ "name": "Action RPG" }],
    "production": { "companies": ["FromSoftware", "Bandai Namco Games"] },
    "platforms": [{ "name": "PlayStation 5", "is_lead": true, "metascore": { "score": 96, "max": 100 } }]
  }
}

The same shape works for movies (/metacritic/movie/{slug}, with tagline and imdb_id fields) and TV (/metacritic/tv/{slug}, with season_count and networks) — check the real fields per content type in the docs:

{
  "code": 200,
  "msg": "OK",
  "data": {
    "id": 456,
    "type": "movie",
    "title": "Oppenheimer",
    "slug": "oppenheimer",
    "tagline": "The World Forever Changes",
    "premiere_year": 2023,
    "release_date": "2023-07-21",
    "rating": "R",
    "metascore": { "score": 90, "max": 100, "review_count": 69, "sentiment": "Universal acclaim" },
    "user_score": { "score": 8.4, "max": 10, "review_count": 2191, "sentiment": "Universal acclaim" },
    "genres": [{ "name": "Biography" }, { "name": "Drama" }],
    "production": { "companies": ["Universal Pictures", "Syncopy"] },
    "imdb_id": "tt15398776"
  }
}

Critic and user reviews come back with the same reviews[] shape across all three verticals — critic reviews carry publication, score, quote, date, and (for games) platform; user reviews carry author, score, quote, and date. Store one row per title (or per review) and re-run browse and title pulls on a schedule.

What you can collect

Browse listings by content type and genre (id, title, slug, url, premiere year, rating, Metascore, user score, genres); game/movie/TV detail (Metascore and User Score objects with review counts and sentiment labels, release date, genres, production companies, and — per type — game platform breakdowns, movie tagline/IMDb id, or TV season count/networks); and critic and user reviews per title (publication or author, score, quote, date, and platform for games). Public aggregate and review data only.

Limitations and common challenges

• One of the stricter platforms in this series. Fandom's Terms of Use explicitly name scraping and data mining and separately restrict AI/ML training use — scope any project to aggregate scores and a bounded, attributed review sample, and get written permission for large-scale or commercial use.
• No official self-serve API, and the one licensed route is partial. Fabric Origin's B2B API needs a paid subscription and approval, and only covers movie/TV Metascores — games aren't included at all.
• Nuxt.js rendering, not the Next.js pattern you'd expect. DIY parsing means picking apart a window.__NUXT__ payload that isn't documented and changes with site updates; the embedded JSON-LD only covers the aggregate Metascore, not the User Score or individual reviews.
• Reviews paginate per title, per review type. A complete title record needs separate calls for critic reviews and user reviews on top of the detail call.
• Reviewer identity is personal data. Usernames and quoted review text can be linked back to individuals — treat review collection under the same GDPR/CCPA lens as any other personal-data scrape, and avoid bulk republishing full review text.

Where this gets used

• Rating research — compare Metascore vs. User Score gaps across games, movies, and TV to study critic/audience divergence.
• Catalog enrichment — attach aggregate scores to a media library, watchlist, or recommendation feature.
• Studio and franchise tracking — follow how a publisher's or studio's releases score over time.
• Release monitoring — watch new releases land and get scored by genre and content type.

Sources

Start collecting

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Test the browse, game, movie, and TV endpoints in the Playground, check the schema in the API docs, and review pricing. Metacritic tells you how critics and audiences scored a title; IMDb tells you who made it and its own separate rating; TMDB fills in clean catalog metadata and artwork; and Rotten Tomatoes adds a second critic/audience scoring system to check Metacritic's score against — pair any two of the four for a fuller media-data pipeline. See also how to choose a web scraping API and is web scraping legal.

Part of our how-to-scrape guide series — every platform we cover, in one index.