How to Scrape IMDb Movies, TV Ratings & Reviews in 2026

IMDb has the deepest public film and TV catalog on the web, but getting structured data out of it is oddly hard. The official datasets are restricted flat files that lag real-time and omit reviews; paid data licenses are expensive; and scraping the rendered pages means fighting layout churn across title, episode, review and person templates. IMDb’s own website, though, is powered by a public GraphQL endpoint — the same one that renders imdb.com — and it serves clean, typed JSON with ratings, votes and reviews included. This guide covers how that GraphQL surface works, what its advanced search can filter on, and how to build a filtered movie/TV dataset or pull every review for a title in one run, with no key and no browser.

What’s worth extracting

The actor exposes six modes through one input form, each row tagged with _mode and scrapedAt. The record shapes by mode:

• Titles (searchTitles, search, titleDetails) — id, title, originalTitle, titleType, year, endYear, aggregateRating, voteCount, runtimeMinutes, genres[], plot, poster imageUrl, topCredits[] (director, writers, cast) and imdbUrl.
• Episodes (episodes) — seriesTitle, seasonNumber, episodeNumber, title, releaseDate, per-episode aggregateRating, voteCount and plot.
• Reviews (reviews) — titleName, author, authorRating, summary, full text, submissionDate, and upVotes / downVotes (helpfulness).
• People (name) — id, name, professions[], birthDate, deathDate, bio, imageUrl and a knownFor[] filmography.

The recurring value is that aggregateRating (the IMDb average) and voteCount sit on every title and every episode, straight from IMDb — which is exactly the pairing most film-analytics work is built on.

How the source actually works

The engine sends direct HTTP GraphQL queries to IMDb’s own public GraphQL endpoint — no API key, no OAuth, no login, no headless browser. Six modes cover the catalog:

Mode	What it returns
searchTitles	Advanced movie/TV search — filter by type, genre, year, rating, votes (highest volume)
search	Free-text search across titles, people and companies
titleDetails	Full details for one or many title IDs (batch)
episodes	Every episode of a TV series, paginated
reviews	User reviews for a title, paginated
name	Person / cast / crew details for one or many name IDs (batch)

The searchTitles mode is the workhorse. It runs against IMDb’s full catalog and filters on title type (movie, tvSeries, tvMiniSeries, tvMovie, short, videoGame…), one or more genres (all must match), a releaseDateStart / releaseDateEnd window, minRating / maxRating bounds, and minVotes to drop obscure entries. You sort by POPULARITY, USER_RATING, USER_RATING_COUNT, RELEASE_DATE, RUNTIME, BOX_OFFICE_GROSS_DOMESTIC or METACRITIC_SCORE, ascending or descending, and it paginates the result set up to your maxResults.

A filtered search for popular recent movies:

{
  "mode": "searchTitles",
  "titleTypes": ["movie"],
  "releaseDateStart": "2020-01-01",
  "minVotes": 5000,
  "sortBy": "POPULARITY",
  "maxResults": 200
}

Reviews for a specific title — the titleId is the digits after tt in an IMDb URL:

{
  "mode": "reviews",
  "titleId": "tt0111161",
  "maxResults": 500
}

Batch title details for several movies at once:

{
  "mode": "titleDetails",
  "titleIds": ["tt0111161", "tt0068646", "tt0468569"]
}

▶ Open the IMDb Scraper on Apify — one run builds a filtered movie/TV ratings dataset, or pulls every user review for a title. IMDb’s own GraphQL, no key, no browser. Export to JSON, CSV or Excel.

The access reality

IMDb’s GraphQL is generous, but there are real shapes to plan around:

• IDs are the currency. A title ID looks like tt0111161; a person ID looks like nm0000138. The detail-oriented modes (titleDetails, episodes, reviews, name) need these IDs. Use searchTitles or search first to discover them, then feed them in.
• Advanced search reaches the whole catalog. A single filter set can match hundreds of thousands of titles; the actor paginates up to your maxResults, so set that deliberately — an unbounded run against a loose filter is a lot of pages.
• minVotes is your quality gate. Without it, a broad genre search surfaces a long tail of obscure entries with a handful of votes. Set minVotes to filter to titles with meaningful rating signal.
• Reviews and episodes paginate. Both walk a paginated feed up to maxResults; a popular film has thousands of reviews, so cap it or expect a longer run.
• Localization is available. Set country and language (e.g. US / en-US, DE / de-DE, TR / tr-TR) to influence IMDb’s localization of titles and text.
• Batch where you can. titleDetails and name accept arrays (titleIds, nameIds), which is far more efficient than one run per ID.

Example output

A title row from searchTitles and a review row from reviews, both carrying _mode:

{
  "_mode": "searchTitles",
  "id": "tt0111161",
  "title": "The Shawshank Redemption",
  "titleType": "movie",
  "year": 1994,
  "aggregateRating": 9.3,
  "voteCount": 2894512,
  "runtimeMinutes": 142,
  "genres": ["Drama"],
  "plot": "Over the course of several years, two convicts form a friendship…",
  "imdbUrl": "https://www.imdb.com/title/tt0111161/",
  "scrapedAt": "2026-07-06T12:00:00.000Z"
}

{
  "_mode": "reviews",
  "titleName": "The Shawshank Redemption",
  "author": "alexdrama",
  "authorRating": 10,
  "summary": "A near-perfect film",
  "text": "Few films earn their reputation the way this one does…",
  "submissionDate": "2026-05-18",
  "upVotes": 142,
  "downVotes": 6,
  "scrapedAt": "2026-07-06T12:00:00.000Z"
}

Typical use cases

• Film and TV analytics — build a ratings dataset filtered by genre, decade and popularity, then chart trends in a BI tool.
• Recommendation engines and ML — bulk-ingest titles, genres, ratings and cast to train content-based or collaborative recommenders.
• Review mining and sentiment — pull IMDb user reviews for a film or series and feed sentiment models or an LLM summarizer.
• Catalog enrichment — augment your own media catalog with IMDb metadata, posters, runtimes and cast lists via titleDetails.
• Market and competitor research — track top-rated or most-popular releases per year, monitor a studio’s back catalog, or benchmark a show’s episode ratings.
• AI agents and RAG — wrap the actor as a tool so an LLM can answer “what are the top-rated sci-fi movies since 2020?” or embed plots and reviews.

Build-it-yourself vs. managed actor

The GraphQL endpoint is discoverable, but the work is substantial: constructing the advanced-search query with its full filter and sort matrix, paginating title/episode/review feeds, normalizing six different response shapes (titles, episodes, reviews, people, search, details) into flat rows with a shared _mode, batching ID lookups, wiring localization, and keeping it all working through IMDb’s persisted-query changes.

On cost, the actor is pay-per-result — you pay for the items you extract, with no restricted-dataset licensing and no separate platform-fee math. A 200-title filtered search or a 500-review pull costs cents to low single dollars, versus a paid IMDb data license or the engineering time to reverse-engineer and maintain the GraphQL layer yourself. Because it’s pay-per-result and keyless, an AI agent can also call it through Apify’s MCP server on demand.

Common pitfalls

• Discover IDs before detail modes. reviews, episodes, titleDetails and name all need tt… / nm… IDs. Run search or searchTitles first; don’t guess IDs.
• Set minVotes on broad searches. A genre-only filter drags in a long obscure tail. minVotes (e.g. 5000) keeps the dataset to titles with real rating signal.
• Cap paginated pulls. Reviews and episodes for popular titles run deep. Set maxResults to bound the run rather than paging the entire feed.
• genres[] is AND, not OR. Listing multiple genres requires all to match. If you want “Action or Comedy,” run them separately and union the results.
• Filter mixed datasets by _mode. Titles, reviews, episodes and people have different fields. If you run several modes into one dataset, pivot on _mode before analysis or you’ll get sparse columns.
• Ratings and votes drift. aggregateRating and voteCount change over time. Store scrapedAt and re-run on a schedule if you’re tracking a title’s trajectory rather than a one-time snapshot.

Wrapping up

IMDb’s public GraphQL gives you the full catalog — advanced filtered search, ratings, votes, reviews, episodes and cast — without the restricted flat-file datasets or a paid license. The work is in the filter-and-sort matrix, the pagination, and normalizing six response shapes into clean rows, which is what this actor packages. Point it at a filter set or an IMDb ID and you have a structured film/TV dataset in one run.

▶ Run the IMDb Scraper on Apify — filtered movie/TV search with ratings and votes on every title, plus reviews, episodes, cast and crew, from IMDb’s own GraphQL. No API key, no browser. Export to JSON, CSV or Excel, and start on Apify’s free monthly credit.