How to Scrape IMDb Data: Ratings, Cast, Reviews

Before writing any code, understand how IMDb identifies things. Two ID types run through the entire site:

These IDs are called tconst and nconst in IMDb's own data. They're stable, so once you have a title's tconst you can build every URL you need: the main page, /fullcredits, /reviews, /ratings. tt0111161 is The Shawshank Redemption, and it's the working example throughout this guide.

Here's the data you can realistically collect per title, and the best source for each:

The pattern to internalize: IMDb hands you structured JSON on almost every page. Parsing rendered HTML with selectors is the last resort, not the first.

Start here, because it changes your whole approach. IMDb's Conditions of Use explicitly prohibit "data mining, robots, screen scraping, or similar data gathering and extraction tools" without written permission. That's a contract term, and violating it can get your accounts and IPs blocked and, in some jurisdictions, expose you to a breach-of-contract claim.

Three things are worth separating:

• Public data access. In the United States, courts (notably hiQ Labs v. LinkedIn) have held that scraping publicly available data isn't by itself a Computer Fraud and Abuse Act violation. That is not the same as saying it's contract-safe or copyright-safe.
• Copyright. Factual data (a runtime, a release year, a rating number) generally isn't copyrightable. User review text is. Storing and republishing review bodies carries real copyright exposure that scraping a rating number does not.
• The sanctioned route. IMDb publishes official datasets for exactly this reason. Per IMDb's own documentation, "Subsets of IMDb data are available for access to customers for personal and non-commercial use." If your use is commercial, the free datasets don't cover you, and neither does scraping the site.

Practical takeaway: for bulk facts (titles, ratings, credits), use the official datasets covered in section 8. Scrape live pages only for the fields datasets don't include, do it at a polite rate, cache aggressively, and don't redistribute copyrighted review text. If you're building something commercial, contact IMDb about a licensed feed. None of this is legal advice, and our own guide on ethical scraping and rate limiting goes deeper on staying on the right side of it.

Open any IMDb title page, view source, and search for application/ld+json. IMDb embeds a schema.org Movie (or TVSeries) object in the page head. It's server-rendered, so it's in the initial HTML before any JavaScript runs. That one detail saves you money later: you don't need a headless browser to read it.

Here's the shape of the block (numeric values reflect the moment you fetch, since ratings move):

{
  "@context": "https://schema.org",
  "@type": "Movie",
  "url": "/title/tt0111161/",
  "name": "The Shawshank Redemption",
  "genre": ["Drama"],
  "contentRating": "R",
  "datePublished": "1994-10-14",
  "duration": "PT2H22M",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 9.3,
    "ratingCount": 2900000,
    "bestRating": 10,
    "worstRating": 1
  },
  "director": [{ "@type": "Person", "name": "Frank Darabont", "url": "/name/nm0001104/" }],
  "actor": [
    { "@type": "Person", "name": "Tim Robbins", "url": "/name/nm0000209/" },
    { "@type": "Person", "name": "Morgan Freeman", "url": "/name/nm0000151/" }
  ]
}

The duration is ISO 8601 (PT2H22M means 2 hours 22 minutes), and each actor and director carries a /name/nm... URL you can follow. Parsing it is a few lines:

import json
from bs4 import BeautifulSoup

def as_list(value):
    if value is None:
        return []
    return value if isinstance(value, list) else [value]

def parse_jsonld(html):
    soup = BeautifulSoup(html, "html.parser")
    block = soup.find("script", {"type": "application/ld+json"})
    data = json.loads(block.string)
    rating = data.get("aggregateRating") or {}
    return {
        "type": data.get("@type"),            # "Movie", "TVSeries", "TVEpisode"
        "title": data.get("name"),
        "content_rating": data.get("contentRating"),
        "genres": as_list(data.get("genre")),
        "runtime_iso": data.get("duration"),  # e.g. "PT2H22M"
        "release": data.get("datePublished"),
        "rating": rating.get("ratingValue"),
        "votes": rating.get("ratingCount"),
        "directors": [d.get("name") for d in as_list(data.get("director"))],
        "cast": [a.get("name") for a in as_list(data.get("actor"))],
    }

That handles the headline fields for titles, ratings, and top cast in one shot, no selector maintenance required. The actor array is capped at the page's featured cast, so for a full credit list you'll go one level deeper in section 6.

The JSON-LD also contains a single review object (the top-voted review) with reviewBody, author, and reviewRating. That's the cheapest way to grab one representative review per title without loading the reviews page.

Reading JSON-LD is easy once you have the HTML. Getting the HTML reliably, at volume, from an anti-bot-aware site is the hard part. IMDb rate-limits by IP and geo-varies its content. The SparkProxy Scraping API takes a target URL and handles the proxy, rotation, and rendering for you. Base URL https://scrape.sparkproxy.io/api/v1, auth via the X-API-Key header.

A basic fetch:

curl "https://scrape.sparkproxy.io/api/v1?url=https://www.imdb.com/title/tt0111161/&render_js=false&country_code=us" \
  -H "X-API-Key: YOUR_API_KEY"

The same call in Python, wrapped so the rest of the guide can reuse it:

import requests

def fetch(url, render_js="false"):
    resp = requests.get(
        "https://scrape.sparkproxy.io/api/v1",
        headers={"X-API-Key": "YOUR_API_KEY"},
        params={
            "url": url,
            "render_js": render_js,   # JSON-LD is in raw HTML, so keep this off here
            "country_code": "us",     # IMDb geo-varies content; pin a region
        },
        timeout=90,
    )
    resp.raise_for_status()
    return resp.text

html = fetch("https://www.imdb.com/title/tt0111161/")
movie = parse_jsonld(html)
print(movie["title"], movie["rating"], movie["votes"])

Note render_js="false". Because the JSON-LD and __NEXT_DATA__ blocks are baked into the initial HTML, you don't pay for a browser render to read them. On the SparkProxy credit model that's the difference between a 1-credit and a 5-credit request per page, which matters a lot across thousands of titles. Turn render_js on only for the reviews pages that lazy-load content (section 7).

If you'd rather not parse HTML yourself, the API's extract_rules parameter pulls fields with CSS selectors server-side:

import json

params = {
    "url": "https://www.imdb.com/title/tt0111161/",
    "render_js": "false",
    "extract_rules": json.dumps({
        "title": "h1",
        "genres": {"selector": "div[data-testid='genres'] a", "type": "list"},
    }),
}

One caveat, and it's the reason JSON-LD wins: IMDb's data-testid attributes and class names change between builds, so selector-based extraction needs babysitting. The JSON-LD schema is far more stable because IMDb keeps it consistent for Google. Prefer the structured blocks; reach for selectors only for fields that live nowhere else.

IMDb's front end is a Next.js app, which means every page ships a