How to Scrape Rotten Tomatoes in 2026 (API & Python)

The fastest way to scrape Rotten Tomatoes in 2026 is to call a structured API that returns normalized JSON — title detail, Tomatometer, Audience Score, and review snippets — for movies, TV series, seasons, and episodes in the same request shape, instead of parsing Rotten Tomatoes' pages yourself or waiting out Fandango's own developer-approval process. Rotten Tomatoes is the default "should I watch this" reference for most of the English-speaking web, but its official API isn't free, isn't fast to get, and its owner's terms explicitly ban automated collection. This guide covers all three approaches, what each returns, where each breaks, and the legal reality up front.

Why scrape Rotten Tomatoes data?

Rotten Tomatoes' Tomatometer and Audience Score anchor a huge amount of downstream reception research, which powers:

• Sentiment and review aggregation — pull critic and audience consensus for a title without re-deriving it from raw reviews yourself.
• Streaming-catalog quality signals — attach a trust signal (Tomatometer, "Certified Fresh") to a title before recommending or licensing it.
• Critic vs. audience divergence research — compare Tomatometer against Audience Score to spot titles where press and public reaction diverge sharply.
• Market and release research — track how new releases score by browsing "in theaters" and "best TV" lists as scores land.
• Cross-referencing with other rating sources — pair Rotten Tomatoes' two-score system with TMDB catalog metadata or Metacritic's Metascore for a fuller reception picture than any one source gives.

Is it legal to scrape Rotten Tomatoes?

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

Rotten Tomatoes' movie and TV pages are React-rendered with score data embedded in a JSON payload alongside the markup, so a DIY scraper generally has to either drive a headless browser or dig out that embedded state:

import requests
from bs4 import BeautifulSoup

resp = requests.get(
    "https://www.rottentomatoes.com/m/inception",
    headers={"User-Agent": "Mozilla/5.0 (compatible; research-bot/1.0)"},
)
soup = BeautifulSoup(resp.text, "html.parser")
# Tomatometer and Audience Score render client-side from a score-details
# JSON blob embedded in the page — there's no clean <script type="application/ld+json">
# AggregateRating block to lean on the way there is on some other review sites

It demos and then breaks:

• The ToS names scraping directly, and it's the strictest ban in this series so far. Fandango's Terms of Use call out robots, spiders, crawlers, and "data gathering or extraction software" by name, plus an explicit AI/ML-training restriction — there's no ambiguity to argue around.
• No clean structured-data fallback. Unlike sites that expose an AggregateRating JSON-LD block, Rotten Tomatoes' Tomatometer and Audience Score live inside client-rendered component state, which means either running a headless browser or reverse-engineering an internal payload shape that isn't documented and changes without notice.
• Four different content types, four different page shapes. Movies, TV series, seasons, and episodes each render differently — a parser tuned for movie pages typically needs separate handling for TV.
• Reviews paginate behind cursor-based "load more" requests. Critic and audience review snippets aren't fully present in the initial HTML; pulling more than the first page means replicating an internal pagination call.

Option 2: No-code / ready-made tools

Marketplace scraper actors exist for one-off Rotten Tomatoes pulls, and they're fine for a spreadsheet export of a handful of titles. They carry the same Terms of Use exposure as DIY scraping, though, and none of them solve the scheduling or multi-platform-schema problem for a real pipeline. The two licensed alternatives — Fandango's own Developer Network and Fabric Origin's B2B API — both require a paid subscription and an approval process; neither has a free or same-day signup path.

Option 3: A structured Rotten Tomatoes API

For a repeatable workflow without a five-figure annual license or a 60-day approval wait, a Rotten Tomatoes scraping API returns normalized JSON with no page parsing to maintain. Search for a title to get its path:

curl "https://api.crawlora.net/api/v1/rottentomatoes/search?query=inception" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{
  "code": 200,
  "msg": "OK",
  "data": {
    "query": "inception",
    "limit": 2,
    "results": [
      {
        "title": "Inception",
        "path": "/m/inception",
        "url": "https://www.rottentomatoes.com/m/inception",
        "release_year": "2010",
        "tomatometer_score": 87,
        "tomatometer_sentiment": "POSITIVE"
      }
    ]
  }
}

Then pull movie, series, or person detail by path in Python:

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

hits = requests.get(f"{base}/search", headers=h, params={"query": "inception"}).json()["data"]["results"]
movie = requests.get(f"{base}/movie", headers=h, params={"path": hits[0]["path"]}).json()["data"]
reviews = requests.get(f"{base}/movie/reviews", headers=h, params={"path": hits[0]["path"], "type": "critics", "limit": 10}).json()["data"]

Movie detail returns Tomatometer and Audience Score as separate objects (real fields — check the docs):

{
  "code": 200,
  "msg": "OK",
  "data": {
    "title": "Inception",
    "path": "/m/inception",
    "url": "https://www.rottentomatoes.com/m/inception",
    "media_type": "Movie",
    "critics_score": { "score_percent": "87%" },
    "audience_score": { "score_percent": "91%" },
    "public_page_derived": true
  }
}

TV works the same way but as a series/season/episode hierarchy — /rottentomatoes/series for the show, /rottentomatoes/season for a season, /rottentomatoes/episode for a single episode:

series = requests.get(f"{base}/series", headers=h, params={"path": "/tv/breaking_bad"}).json()["data"]
season = requests.get(f"{base}/season", headers=h, params={"path": "/tv/breaking_bad/s01"}).json()["data"]
episode = requests.get(f"{base}/episode", headers=h, params={"path": "/tv/breaking_bad/s01/e01"}).json()["data"]

{
  "code": 200,
  "msg": "OK",
  "data": {
    "title": "Breaking Bad",
    "path": "/tv/breaking_bad",
    "url": "https://www.rottentomatoes.com/tv/breaking_bad",
    "media_type": "TvSeries",
    "number_of_seasons": 5,
    "critics_score": { "score_percent": "96%" },
    "audience_score": { "score_percent": "97%" },
    "public_page_derived": true
  }
}

/rottentomatoes/person returns a cast/crew member's filmography with per-title critic scores; /rottentomatoes/browse/movies and /rottentomatoes/browse/tv return curated lists (movies in theaters, best TV shows, and similar) filterable by sort and limit. Store one row per title (or per review) and re-run search and browse pulls on a schedule.

What you can collect

Title search (title, path, url, release year, Tomatometer score and sentiment); movie, series, season, and episode detail (Tomatometer and Audience Score as separate percentage objects, media type, season/episode counts, parent-series and parent-season references, air dates); critic and audience review snippets per title (display name and review excerpt, cursor-paginated); person detail (name, birth date, birthplace, highest-rated title, and filmography with per-title critic scores); and curated browse lists for movies in theaters and top TV shows. Public aggregate and review data only.

Limitations

• The strictest ToS in this series so far. Fandango explicitly names robots, spiders, crawlers, and data-extraction software, and separately bans AI/ML training use — scope any project to aggregate scores and a bounded, attributed review sample, and pursue licensed access for anything at scale.
• No free official API, and both licensed routes are paid and approval-gated. Fandango's own Developer Network reportedly starts around $60,000/year with up to a 60-day review; Fabric Origin's B2B alternative also requires a paid subscription and account approval.
• No clean JSON-LD fallback. Scores render from client-side component state rather than a structured-data block, so DIY parsing means either a headless browser or reverse-engineering an undocumented payload.
• Reviews paginate behind a cursor. A complete review sample for a title needs repeated calls following page_info.end_cursor, not one page load.
• Reviewer identity is attributable. Critic and audience review snippets are attached to a named reviewer — treat review collection under the same personal-data lens as any other named-review scrape, and avoid bulk republishing full review text.

Where this gets used

• Reception research — compare Tomatometer against Audience Score to study critic/audience divergence across genres or release windows.
• Catalog quality signals — attach a trust score to a title before featuring or licensing it in a streaming or discovery product.
• Studio and release tracking — follow how new releases score as they land in theaters or on TV.
• Multi-source enrichment — pair Rotten Tomatoes' two-score system with TMDB catalog metadata or Metacritic's critic/user scores in one pipeline.

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 search, movie, series, and person endpoints in the Playground, check the schema in the API docs, and review pricing. Rotten Tomatoes tells you how critics and audiences scored a title; TMDB fills in clean catalog metadata and artwork, and Metacritic adds a second critic/user scoring system to compare against — pair any two for a fuller reception picture than one source gives. To see whether reception tracked with revenue, how to scrape Box Office Mojo adds the gross and chart data critic scores don't cover. 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.