TMDB + Rotten Tomatoes + Metacritic Scraper: 77 Data Fields per Record

Unified entertainment data across movies, TV series, and media personalities costs $5.00 per 1,000 results on Apify's free plan. Every record carries 77 output fields, including platform, recordType, title, year, rating, and url, alongside platform-native attributes like tomatometer, metascore, and tmdbId. A suite of 29 input controls lets you switch platforms or toggle parameters like fetchDetail and appendToResponse. This tool is built for data engineers building cross-platform review aggregates; it is not for users who need localized title names from Rotten Tomatoes or Metacritic, as those surfaces support English only.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open TMDB + Rotten Tomatoes + Metacritic Scraper on Apify and run the prefilled example.

How reliable is TMDB + Rotten Tomatoes + Metacritic Scraper in production?

Across the last 30 days of public runs on the Apify platform, TMDB + Rotten Tomatoes + Metacritic Scraper recorded 123 runs with the following outcomes.

No run failed or timed out in the last 30 days. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run TMDB + Rotten Tomatoes + Metacritic Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The maxItems input control has the largest impact on your result charges because it places a hard cap on how many dataset items a run writes. Setting fetchDetail to true instructs the Actor to follow list items to detail pages for full metadata, but it does not change the result count charge. Run a quick test with maxItems set to 5 on popular mode to confirm the output structure before scaling up.

How do you run TMDB + Rotten Tomatoes + Metacritic Scraper from the API?

The schema marks 2 of its 29 controls as required: platform, mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~tmdb-rt-metacritic-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"platform":"rottentomatoes","mode":"popular"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "platform": "rottentomatoes",
  "mode": "popular"
}

run = client.actor("crawlerbros~tmdb-rt-metacritic-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "platform": "rottentomatoes",
  "mode": "popular"
}

const run = await client.actor('crawlerbros~tmdb-rt-metacritic-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which TMDB + Rotten Tomatoes + Metacritic Scraper inputs matter, and which can you skip?

The required platform and mode controls determine which site is queried and which retrieval mechanism is used. When setting platform to tmdb, you must also provide an API key in tmdbApiKey, whereas Rotten Tomatoes and Metacritic modes require no API key. Optional parameters like genre, year, or minRating help narrow down listings before records are emitted.

• platform (string): Which source to scrape. Default: "rottentomatoes".
• mode (string): What to fetch. Available modes vary by platform - see README. Default: "popular".
• mediaType (string): Movie, TV show, person, or all (multi). Some modes only apply to one type - see README. Default: "movie".
• tmdbApiKey (string): Free TMDB v3 API key - sign up at https://www.themoviedb.org/settings/api. Leave empty if scraping Rotten Tomatoes or Metacritic only.
• searchQuery (string): Free-text query. e.g. oppenheimer, breaking bad, Christopher Nolan. Default: "oppenheimer".
• titles (array): List of TMDB numeric IDs, RT slugs (oppenheimer_2023), or Metacritic slugs (oppenheimer). Mixed inputs work - the actor disambiguates by platform. Default: [].
• urls (array): Full URLs. Examples: https://www.themoviedb.org/movie/872585, https://www.rottentomatoes.com/m/oppenheimer_2023, https://www.metacritic.com/movie/oppenheimer/. Default: [].
• personId (string): TMDB person ID (e.g. 525). Returns full filmography.
• tmdbList (string): Which TMDB curated movie list to fetch (only when platform=tmdb).
• trendingWindow (string): TMDB trending window - daily or weekly. Default: "week".
• genre (string): Genre name. TMDB maps to numeric IDs; RT/MC apply substring filtering on the page.
• year (integer): Primary release year (TMDB) / browse-by-year (RT, MC).

The other 17 controls, with their defaults, are listed in the input schema on TMDB + Rotten Tomatoes + Metacritic Scraper on Apify.

Fixed-choice controls: platform accepts tmdb (themoviedb.org official API - requires API key), rottentomatoes (Tomatometer + Audience Score), metacritic (Metascore + User Score); mode accepts 12 values (default popular), including popular (Popular / browse listing), search (text query), byTitle (Lookup by ID / slug / title (exact)), byUrl (Lookup by full URL (TMDB / RT / MC)); mediaType accepts movie, tv (TV Show), person (TMDB only), multi (All / Multi (TMDB search.multi only)); tmdbList accepts popular, top_rated (Top rated), upcoming (movie only), now_playing (movie only), airing_today (TV only), on_the_air (TV only); trendingWindow accepts day, week; genre accepts 29 values, including Action, Adventure, Animation, Anime.

What does TMDB + Rotten Tomatoes + Metacritic Scraper return?

Returned records provide normalized attributes like title, release year, and platform-specific ratings like tomatometer or metascore. They lack uniform nested objects, as cast lists range from simple string arrays on Rotten Tomatoes and Metacritic to structured cast objects when requesting TMDB extras.

• platform - tmdb, rottentomatoes, or metacritic.
• recordType - movie, tv, or person.
• mediaType - same as recordType for media entries.
• title - display name.
• year - first release year (when available).
• rating - primary rating on each platform (TMDB vote_average 0-10, RT Tomatometer 0-100, MC Metascore 0-100).
• url - canonical URL on the platform.
• scrapedAt - ISO-8601 timestamp.
• TMDB: tmdbId, voteCount, popularity, posterUrl, backdropUrl, genres (names), genreIds, cast, crew, videos, similar, recommendations, keywords, imdbId, tvdbId, runtime, tagline, status, homepage, budget, revenue, productionCompanies, spokenLanguages, numberOfSeasons, numberOfEpisodes, networks, createdBy, originalTitle, originalLanguage, overview, releaseDate, firstAirDate, lastAirDate, originCountry, inProduction, adult, biography, birthday, deathday, placeOfBirth, gender, alsoKnownAs, knownFor, knownForDepartment.
• Rotten Tomatoes: tomatometer, audienceScore, tomatometerCertified, tomatometerSentiment, audienceSentiment, criticsReviewCount, cast, directors, genres, synopsis, posterUrl, slug, endYear, datePublished.
• Metacritic: metascore, userScore, criticsReviewCount, cast, directors, genres, synopsis, contentRating, posterUrl, slug, releaseDate.

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open TMDB + Rotten Tomatoes + Metacritic Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set platform to rottentomatoes, metacritic, or tmdb depending on your target source.
2. Select a retrieval strategy in mode, such as popular, search, or byTitle.
3. If platform is tmdb, paste a free API key from themoviedb.org into tmdbApiKey.
4. Set maxItems to 5 on your first run to check the dataset structure before requesting larger runs.
5. Keep fetchDetail set to true if your pipeline requires secondary fields like synopsis, cast, or directors.
6. Execute the Actor and inspect the dataset tab in the Apify console.
7. Verify that output records include expected core fields like platform, title, year, rating, and url.
8. Increase maxItems to your target batch size once output fields match your acceptance criteria.

How do you apply it? Three worked playbooks

These are TMDB + Rotten Tomatoes + Metacritic Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Yearly rating leaderboard

Outcome: Build a "best films of " leaderboard combining all three rating systems.

Configure: Set platform to rottentomatoes, mode to byYear, year to 2023, and maxItems to 50.

Working method: Execute separate runs for each platform choice using matching release year settings, then merge output records on title and year.

Deliverable: A combined dataset containing normalized scores across Tomatometer, Metascore, and TMDB vote averages for a designated year.

Stop condition: Zero records written or primary rating fields missing across more than 20% of returned items.

Use case 2: Critic vs audience cross-reference

Outcome: Cross-reference critic vs. audience scores for any title (TMDB vote, Tomatometer, Audience, Metascore, User Score).

Configure: Set platform to rottentomatoes, mode to byTitle, titles to ["oppenheimer_2023"], and fetchDetail to true.

Working method: Pass specific title slugs or identifiers across each platform option, then align critic scores alongside audience ratings in your output.

Deliverable: A unified record set comparing critic percentages against audience ratings for target titles.

Stop condition: The titles list returns empty dataset items or fails slug resolution on the designated platform.

Use case 3: Director filmography pull

Outcome: Pull a director's full TMDB filmography in a single run.

Configure: Set platform to tmdb, mode to byPerson, personId to "525", tmdbApiKey to "YOUR_TMDB_KEY", and appendToResponse to ["credits"].

Working method: Query a TMDB person identifier directly to extract complete filmography lists, then filter credits by job or department downstream.

Deliverable: An array of credits detailing release dates, vote averages, character names, and crew attributes.

Stop condition: The returned person record yields an empty credits array or returns zero records due to an invalid tmdbApiKey.

What breaks, and how do you design around it?

• TMDB requires a free API key at https://www.themoviedb.org/settings/api. Without it, the actor emits a status message and 0 records - by design (TMDB's terms forbid sharing the actor author's key).
• RT and MC are English-only - they don't expose localized titles. If you set language=fr-FR, TMDB returns French titles; RT/MC ignore the setting.
• RT pagination is single-page for popular / browse listings (~50 items per fetch). MC supports ?page=N (≤5 pages, ≈25 records each).
• Some RT pages don't expose Audience Score before opening night; the field is omitted (per the omit-empty rule).
• MC userScore is 0-10 (not 0-100 like Metascore). Both fields are emitted side-by-side when available.
• Record types are flat - cast is a list of strings on RT/MC but a list of {name, character, tmdbId} objects on TMDB. Filter / project accordingly downstream.
• Daily test default: platform=rottentomatoes, mode=popular, maxItems=10. This produces ≥1 record without any user-supplied secrets. For TMDB modes, set tmdbApiKey on the test page.
• Robots / search paths: rottentomatoes.com and metacritic.com robots.txt lists /search under Disallow: * (no Crawl-delay). The actor's mode=search only runs on explicit user-supplied queries (not bulk discovery) and paces requests at 0.25-0.3s. Detail / browse modes use unrestricted paths (/m/, /tv/, /movie/, /browse/). TMDB calls hit the official api.themoviedb.org REST endpoint under your own API key.

Always provide a valid API key in tmdbApiKey when selecting TMDB, or the Actor will emit 0 records with a status message. If HTTP 403 or 429 blocks occur while scraping Rotten Tomatoes or Metacritic, keep autoEscalateOnBlock set to true so Apify Proxy is automatically engaged. When using discover mode, raise minVoteCount to avoid obscure entries with inflated average ratings.

When should you not use TMDB + Rotten Tomatoes + Metacritic Scraper?

Do not use this Actor if you only need detailed Metacritic editorial reviews, full cast bios, and user review text. For deeper Metacritic coverage without multi-platform overhead, use Metacritic Movie & TV Reviews Scraper instead. If your primary objective is tracking multi-region streaming availability across providers like Netflix or Disney+, switch to JustWatch + Trakt Scraper, which handles regional platform licensing across more than 60 countries.

What should you check before trusting the output?

• Confirm that title and year are present on emitted objects, as missing values indicate an unparsed list layout.
• Check that rating is non-null, keeping in mind TMDB uses a 0-10 scale while Rotten Tomatoes and Metacritic use 0-100.
• Verify tmdbApiKey is populated when platform is tmdb, as an empty key causes the Actor to emit 0 records with a status message.
• Confirm fetchDetail is true if your integration relies on synopsis, which is omitted on list-only card extractions.
• Halt downstream processing if record counts fall to zero on scheduled browse or popular runs.

None of this proves a record is correct. It gives a scheduled TMDB + Rotten Tomatoes + Metacritic Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does running this scraper cost?

Results cost $0.005 each, which equals $5.00 per 1,000 results on Apify's free plan. Paid Apify plans reduce this result charge down to $3.00 per 1,000 results.

Do I need proxy credentials or API keys to run it?

Rotten Tomatoes and Metacritic require no API keys or proxy setups. TMDB modes require a free API key from themoviedb.org entered into the tmdbApiKey parameter.

Why does my TMDB run emit zero records?

TMDB modes require a free API key in tmdbApiKey. Without it, the Actor emits a status message and 0 records because TMDB's terms forbid sharing the author's key.

Can I fetch localized movie titles in other languages?

TMDB supports localized titles and overviews using the language control (such as fr-FR). Rotten Tomatoes and Metacritic surfaces expose English content only.

How are anti-bot blocks handled on Rotten Tomatoes and Metacritic?

When autoEscalateOnBlock is set to true, the Actor automatically engages Apify Proxy upon encountering HTTP 403 or HTTP 429 response codes.

Where to go next

When you are ready to run it, open TMDB + Rotten Tomatoes + Metacritic Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the TMDB + Rotten Tomatoes + Metacritic Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Metacritic Movie & TV Reviews Scraper: Scrape Metacritic search results, title pages, and browse listings for movies and TV shows, including Metascore, user score, synopsis, cast, and release metadata.
• JustWatch + Trakt Scraper: Combined movies/TV scraper covering JustWatch (60+ countries, streaming-availability + offers) and Trakt (movies/shows/episodes/people, popular/trending/anticipated).
• ZocDoc + Healthgrades Doctors & Reviews Scraper: Scrape physicians, specialists, ratings, reviews, accepted insurance, locations, and bio data from ZocDoc.com and Healthgrades.com.
• Reddit MCP Scraper: Unified Reddit scraper supporting 3 modes: (1) Subreddit posts with content extraction, (2) Post comments with threading, (3) User profiles with metadata.

Related guides:

• Reddit MCP Scraper: Up to 2,500 Free Results a Month (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-03.

• Actor last updated by its maintainers on 2026-07-05.

• Run outcome figures cover the 30 day public window ending 2026-10-03.

• TMDB + Rotten Tomatoes + Metacritic Scraper on Apify