Rotten Tomatoes Movies & Reviews Scraper

Extract public Rotten Tomatoes movie and TV metadata, Tomatometer scores, audience scores, critic reviews, and audience reviews from Rotten Tomatoes URLs.

Use this actor when you need structured review intelligence for media research, entertainment marketing, reputation monitoring, content planning, or internal analytics.

At a glance

• Best for: movie and TV review research, entertainment marketing, title monitoring, content planning, and media analytics.
• Inputs: Rotten Tomatoes title or review URLs, review type selection, review limit per title, audience-review toggle, and proxy settings.
• Outputs: title metadata rows plus critic, top critic, audience, or verified audience review rows.
• Exports: download CSV, JSON, Excel, XML, RSS, or use the Apify Dataset API.
• Cost: $0.005 per run plus the item event for each saved metadata or review row.

Ready-to-run examples

• Dune Part Two scores and reviews - collect title scores plus critic and audience review rows.
• Oppenheimer top critic reviews - focus on the top critic stream for one title.
• Barbie verified audience reviews - collect verified audience review samples.
• Compare award movie reviews - run multiple movie URLs in one small comparison task.
• Toy Story critic and audience reviews - test both critic and audience output formats.

What can it do?

This actor turns public Rotten Tomatoes title pages and review pages into clean dataset rows.

• Collect title metadata: save title, media type, description, release data, runtime, rating, genres, directors, and cast when visible.
• Export score data: collect Tomatometer and audience scores plus available review counts.
• Extract critic reviews: save reviewer names, publications, excerpts, sentiment signals, dates, ratings, and source URLs.
• Extract audience reviews: save public audience review text, display names, star ratings, dates, and verified flags when available.
• Compare title reactions: run several Rotten Tomatoes URLs in one job and export normalized rows for analysis.
• Use as a Rotten Tomatoes data workflow: run from Apify API, export CSV/Excel/JSON, schedule monitoring, or expose the Actor to AI agents through Apify MCP.

Who is it for?

• Media analysts: track critic and audience reactions across movies and shows.
• Entertainment marketers: monitor public review excerpts, score changes, and audience sentiment signals.
• SEO and content teams: build comparison pages, review roundups, title pages, and market snapshots from structured data.
• Data teams: feed normalized movie review data into dashboards, warehouses, BI tools, or internal enrichment pipelines.
• Reputation monitors: watch how a title is being described by publications and public audiences.

Why use this actor?

Rotten Tomatoes is a high-signal public source for entertainment reputation.

Manual copying is slow, inconsistent, and hard to repeat.

This actor gives you repeatable extraction with clear columns, pagination support, and both title-level and review-level context.

Output groups

Field group	Examples
Title identity	mediaTitle, media URL, media type, Rotten Tomatoes vanity path
Release metadata	release date, release year, content rating, runtime
Creative metadata	genres, directors, cast when visible
Scores	Tomatometer score, audience score, review counts, average ratings
Critic reviews	critic name, publication, top critic flag, quote, sentiment, review URL
Audience reviews	display name, verified flag, star rating, review text, date
Traceability	input URL, source endpoint, pagination cursor, scraped timestamp

Pricing

The actor uses pay-per-event pricing.

You pay a $0.005 start fee per run and a tiered item fee for each saved dataset row.

A row can be a title metadata row or a review row. The standard BRONZE price is $0.000028206 per row, about $0.028 per 1,000 saved rows.

Use a low maxReviewsPerTitle value for a small first test.

Increase the limit when you are satisfied with the output format.

How to use it

1. Open the actor on Apify.
2. Add one or more Rotten Tomatoes movie, TV, or review URLs.
3. Choose the review types you want.
4. Set the maximum number of reviews per title and type.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

Supported URLs

You can provide URLs such as:

https://www.rottentomatoes.com/m/toy_story
https://www.rottentomatoes.com/m/toy_story/reviews
https://www.rottentomatoes.com/m/toy_story/reviews?type=user

Review URLs are normalized back to their title page so the actor can collect both title context and review data.

Input configuration

Setting	JSON key	What it does
Rotten Tomatoes URLs	startUrls	Movie, TV, or review URLs to process. Review URLs are normalized back to their title page.
Review types	reviewTypes	Any combination of critic, topCritic, audience, and verifiedAudience.
Include audience reviews	includeAudienceReviews	Convenience toggle for including audience reviews in addition to selected critic streams.
Maximum reviews per title and type	maxReviewsPerTitle	Limit applied separately for each selected review type on each title. Two titles with critic and audience selected and a limit of 25 can return up to 100 review rows plus two metadata rows.
Proxy configuration	proxyConfiguration	Optional proxy settings. Direct HTTP requests are the default; enable Apify Proxy if your environment requires it.

Example input

{
  "startUrls": [
    { "url": "https://www.rottentomatoes.com/m/toy_story" }
  ],
  "reviewTypes": ["critic", "audience"],
  "includeAudienceReviews": true,
  "maxReviewsPerTitle": 25,
  "proxyConfiguration": { "useApifyProxy": false }
}

Example output

{
  "mediaTitle": "Toy Story",
  "reviewType": "critic",
  "tomatometerScore": 100,
  "audienceScore": 92,
  "reviewerName": "Sarah Vincent",
  "publicationName": "Sarah G Vincent Views",
  "reviewSentiment": "POSITIVE",
  "reviewQuote": "Toy Story is a midlife crisis...",
  "reviewDate": "2026-06-19T10:51:07.000Z",
  "mediaUrl": "https://www.rottentomatoes.com/m/toy_story"
}

Output fields

Field	Description
sourceUrl	URL supplied in the input
mediaUrl	Canonical Rotten Tomatoes title URL
mediaVanity	Rotten Tomatoes path identifier
mediaType	Movie or TV type when visible
emsId	Rotten Tomatoes internal title id when visible
mediaTitle	Movie or show title
description	Public title description
releaseDate	Release date when visible
releaseYear	Release year derived from release date
runtime	Runtime when visible
rating	Content rating or certification
genres	Public genre list
directors	Public director list
cast	Public cast list when present
tomatometerScore	Critic score percentage
tomatometerReviewCount	Critic review count
audienceScore	Audience score percentage
audienceReviewCount	Audience review count
reviewType	metadata, critic, topCritic, audience, or verifiedAudience
reviewerName	Critic or audience display name
isTopCritic	Whether the critic is marked top critic
isVerifiedAudience	Whether the audience review is verified
publicationName	Critic publication name
reviewQuote	Review excerpt or audience review text
reviewSentiment	Fresh/rotten or positive/negative signal when available
reviewRating	Original rating or star value when available
reviewDate	Review creation date
reviewUrl	External review URL when available
reviewId	Public review or rating id
language	Review language when available
scrapedAt	Timestamp when the row was saved

Tips for best results

• Start with one URL: confirm the output format before adding a larger title list.
• Use a low review limit first: audience streams can be large, so increase maxReviewsPerTitle gradually.
• Choose only needed review types: collecting fewer streams keeps runs faster and easier to review.
• Use JSON for systems: export JSON when sending records to another API, warehouse, or app.
• Use CSV or Excel for review: spreadsheet exports are easier for editorial and research workflows.

Integrations

You can connect the dataset to:

• Google Sheets for editorial tracking
• BigQuery or Snowflake for analytics
• Airtable for research queues
• Slack alerts for monitored titles
• Zapier or Make workflows for no-code automation
• Internal dashboards for movie and TV score monitoring

API usage with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/rotten-tomatoes-movies-reviews-scraper').call({
  startUrls: [{ url: 'https://www.rottentomatoes.com/m/toy_story' }],
  reviewTypes: ['critic', 'audience'],
  maxReviewsPerTitle: 25
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/rotten-tomatoes-movies-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.rottentomatoes.com/m/toy_story'}],
    'reviewTypes': ['critic', 'audience'],
    'maxReviewsPerTitle': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

API usage with cURL

curl -X POST "https://api.apify.com/v2/acts/fetch_cat~rotten-tomatoes-movies-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.rottentomatoes.com/m/toy_story"}],
    "reviewTypes": ["critic", "audience"],
    "maxReviewsPerTitle": 20
  }'

MCP and AI agents

Use this actor through the official Apify MCP server when working in Claude Code, Claude Desktop, or other MCP-compatible tools.

MCP server URL:

https://mcp.apify.com?tools=fetch_cat/rotten-tomatoes-movies-reviews-scraper

Claude Code setup:

$claude mcp add apify https://mcp.apify.com?tools=fetch_cat/rotten-tomatoes-movies-reviews-scraper

Claude Desktop or other MCP client configuration:

{
  "mcpServers": {
    "apify-rotten-tomatoes": {
      "url": "https://mcp.apify.com?tools=fetch_cat/rotten-tomatoes-movies-reviews-scraper"
    }
  }
}

The default Apify MCP server can search and run Actors. The focused URL exposes only this Actor to clients that support tool-scoped MCP connections.

Example prompts:

• "Scrape critic reviews for this Rotten Tomatoes URL and summarize recurring praise."
• "Collect audience reviews for these three titles and compare sentiment."
• "Create a table of Tomatometer and audience scores for my movie list."

Common workflows

• Track a release: run the Actor daily for the same title and compare new review rows over time.
• Build critic quote collections: collect critic review excerpts and filter by publication, date, or sentiment.
• Compare critic and audience reaction: select both critic and audience reviews, then group by reviewType.
• Enrich a movie database: use title metadata and score fields to enrich internal movie or TV records.

Troubleshooting

The actor saved metadata but no reviews

The title page may not expose the public review identifier needed for pagination, or the selected review type may have no public rows.

Try a lower limit and a well-known public title first.

I requested top critic or verified audience reviews and received fewer rows

Those modes filter the public critic or audience stream. If few rows match the flag, the output can be smaller than the limit.

Some fields are empty

Rotten Tomatoes does not expose every field for every title or review. Empty values are returned as null or empty arrays.

FAQ

Can I scrape both critic and audience reviews in one run?

Yes. Select both critic and audience in reviewTypes, or keep includeAudienceReviews enabled.

Can I use Rotten Tomatoes review data through the API?

Yes. Start runs with the Apify API, then export the default dataset as JSON, CSV, Excel, or via client libraries.

Why do top critic or verified audience modes return fewer rows?

Those modes filter available public review streams by their public flags. Some titles have fewer matching rows than the requested maximum.

Is this an alternative to manually copying Rotten Tomatoes reviews?

Yes. It automates collection of public title context, scores, review quotes, publication names, dates, ratings, and URLs.

Legality and responsible use

This actor extracts publicly available information from Rotten Tomatoes pages and public review data.

You are responsible for using the data in a lawful way and respecting applicable terms, privacy rules, and intellectual property rights.

Do not use the actor to collect private account data or bypass access controls.

Limits

The actor is designed for public title and review pages.

It does not log in.

It does not collect private user profile data.

It does not guarantee that every historical review is available from public pages.

Related actors

Explore other Apify scrapers from the same publisher:

• YouTube Video Details Scraper
• YouTube Comments Scraper
• Google News Scraper
• Reddit Scraper

Changelog

• 2026-07-02 - Feature: Added ready-to-run Rotten Tomatoes Movies & Reviews example tasks on the Apify Store (APIA-1155)

• 2026-07-02 - Feature: Launched Rotten Tomatoes Movies & Reviews Scraper on Apify Store (APIA-1151)

  • This actor is now publicly available on Apify Store.

0.1

Initial version with Rotten Tomatoes title metadata, critic reviews, audience reviews, score fields, and review traceability.

Support

If you need help, open an issue from the actor page on Apify and include your run ID plus a short description of the expected output.