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.

What does Rotten Tomatoes Movies & Reviews Scraper do?

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

It can collect:

• 🍅 Title metadata
• 🍅 Tomatometer scores
• 🍿 Audience scores
• 📝 Critic review excerpts
• 🧑 Audience review excerpts
• 🏆 Top critic flags
• ✅ Verified audience flags
• 🔗 Review source URLs

Each run starts from the Rotten Tomatoes URLs you provide.

The actor saves one metadata row for each title and then saves review rows for the selected review types.

Review availability: If the public review API fails before the first page, the Actor saves the review previews embedded in the title page instead. These are a limited sample (often up to six per type), not the full review collection, and may return fewer rows than your requested limit. extractionSource: "title-page-preview" identifies these rows; sourceEndpoint points to the title page and paginationCursor is null. If the API fails after a page was saved, the Actor preserves those API rows without appending overlapping previews. Some titles have no previews or no matching top/verified reviews. Full pagination remains unavailable while Rotten Tomatoes rejects API requests.

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 when the public review API is available, and both title-level and review-level context.

What data can you extract?

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

This Actor uses Apify pay-per-event pricing. The start event is charged once when a run starts. The item event is charged for each saved metadata or review row, including title-page previews. Check the live Pricing tab for current rates and plan discounts.

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

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

Rotten Tomatoes movie or review URLs

Add the titles you want to process.

The prefilled example uses a public movie page.

Review types

Choose any combination of:

• Critic reviews
• Top critic reviews
• Audience reviews
• Verified audience reviews

Maximum reviews per title and type

This limit applies separately for each selected review type on each title.

For example, two titles with critic and audience reviews selected and a limit of 25 can return up to 100 review rows plus two metadata rows.

Proxy configuration

The default uses direct HTTP requests.

If your environment requires it, enable Apify Proxy in the advanced options.

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
extractionSource	title-page for metadata, review-api for API reviews, or title-page-preview for a limited, non-paginated fallback sample
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; title-page previews provide a day-only date when visible
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 and a low review limit.

Use multiple URLs only after confirming that the output matches your workflow.

Choose only the review types you need.

Audience reviews can be numerous, so increase limits gradually.

Export JSON when sending data to another system.

Export CSV or Excel for spreadsheets.

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 integration

Use this actor through Apify MCP 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"
    }
  }
}

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 scrapers

Explore other Apify scrapers from the same publisher:

• https://apify.com/fetch_cat/imdb-scraper
• https://apify.com/fetch_cat/youtube-scraper
• https://apify.com/fetch_cat/google-search-scraper

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.