Rotten Tomatoes Reviews Scraper

Scrape Rotten Tomatoes critic and audience reviews from movie, TV season, and TV episode review pages. The actor extracts review text, reviewer names, ratings, critic/publication metadata, freshness/sentiment, dates, profile links, original review links, and source metadata into a clean Apify dataset.

Use it for launch tracking, media research, competitor analysis, reputation monitoring, audience sentiment workflows, and recurring reporting around film and streaming titles.

What does Rotten Tomatoes Reviews Scraper do?

Rotten Tomatoes Reviews Scraper turns public Rotten Tomatoes review pages into structured data.

It supports:

• 🍅 Movie review pages such as /m/oppenheimer_2023/reviews
• 📺 TV season review pages such as /tv/the_last_of_us/s01/reviews
• 🧾 Critic review tabs, including all critics and top critics
• 👥 Audience review tabs, including all audience and verified audience reviews
• 🔗 Pagination through Rotten Tomatoes review API cursors
• 📦 Export to JSON, CSV, Excel, XML, RSS, or HTML through Apify datasets

Who is it for?

Media teams use the scraper to monitor critic response during film and TV launch windows.

Studios and streamers use it to compare audience response across titles and markets.

Distributors use it to build review dashboards before and after theatrical or streaming releases.

PR and reputation teams use it to identify critic quotes, publications, and date patterns.

Data analysts use it to feed review text into sentiment analysis, LLM classification, BI tools, or alerting workflows.

Why use this actor?

Rotten Tomatoes pages are optimized for browsing, not bulk analysis. This actor extracts the same review data into a repeatable dataset without manual copy-paste.

The actor is HTTP-first and lightweight. It reads the public page metadata, then calls the Rotten Tomatoes review endpoints used by the page itself. That keeps runs fast and avoids browser overhead.

Key features

• Extract critic reviews and audience reviews in one run
• Select all critics, top critics, all audience, or verified audience tabs
• Scrape multiple Rotten Tomatoes URLs in a single run
• Capture review text, reviewer, publication, rating, sentiment, and dates
• Preserve Rotten Tomatoes source URLs and original publication review URLs
• Works with movies, TV seasons, and TV episodes where Rotten Tomatoes exposes review pages
• Built for scheduled monitoring and repeatable datasets

Data fields

Field	Description
reviewId	Rotten Tomatoes review or audience rating identifier
mediaTitle	Movie, TV season, or episode title
mediaType	Rotten Tomatoes media type, such as Movie or TvSeason
mediaUrl	Canonical Rotten Tomatoes title URL
reviewsUrl	Input review page URL
reviewType	Selected tab: all critics, top critics, all audience, or verified audience
reviewerName	Critic or audience reviewer display name
reviewerProfileUrl	Rotten Tomatoes critic/user profile URL when public
publicationName	Critic publication name
publicationUrl	Rotten Tomatoes publication profile URL
isTopCritic	Whether the critic is top-critic / top-review tagged
rating	Audience rating token when available
scoreSentiment	Critic sentiment such as positive or negative
isVerifiedAudience	Whether an audience review is verified
isSuperReviewer	Rotten Tomatoes super reviewer flag
hasSpoilers	Audience spoiler flag when available
reviewText	Clean review quote or audience review text
reviewDate	Review creation date
originalReviewUrl	External publication URL for critic reviews
language	Review language when provided
pageNumber	Rotten Tomatoes API page number crawled
scrapedAt	Timestamp when the actor saved the item

How much does it cost to scrape Rotten Tomatoes reviews?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-review fee for each saved dataset item. The final price shown by Apify depends on your plan tier and the live Store pricing table.

To control cost:

• Start with one URL and a low maxItems value
• Use only the review tabs you need
• Increase maxPagesPerUrl for deeper monitoring runs
• Schedule smaller recurring runs instead of very large ad hoc runs when possible

Input

The main input is startUrls.

Each URL should point to a Rotten Tomatoes movie, TV season, or TV episode page. If you pass a title page without /reviews, the actor automatically normalizes it to the reviews page.

Example:

{
  "startUrls": [
    { "url": "https://www.rottentomatoes.com/m/oppenheimer_2023/reviews" }
  ],
  "reviewTypes": ["all-critics", "all-audience"],
  "maxItems": 100,
  "maxPagesPerUrl": 8,
  "pageSize": 20
}

Input fields

startUrls is required. Add one or more Rotten Tomatoes title or reviews URLs.

reviewTypes controls which tabs are extracted. Supported values are all-critics, top-critics, all-audience, and verified-audience.

maxItems limits the total number of reviews saved across all URLs and selected review types.

maxPagesPerUrl limits pagination depth per URL and review type.

pageSize controls how many reviews are requested from Rotten Tomatoes per API request. Rotten Tomatoes may cap audience pages below this value.

Output example

{
  "reviewId": "103071279",
  "mediaTitle": "Oppenheimer",
  "mediaType": "Movie",
  "mediaUrl": "https://www.rottentomatoes.com/m/oppenheimer_2023",
  "reviewsUrl": "https://www.rottentomatoes.com/m/oppenheimer_2023/reviews",
  "reviewType": "all-critics",
  "reviewerName": "Anna Smith",
  "publicationName": "Rolling Stone UK",
  "isTopCritic": true,
  "scoreSentiment": "POSITIVE",
  "reviewText": "A powerful, visually spectacular drama...",
  "reviewDate": "2025-10-30T20:44:46.000Z",
  "originalReviewUrl": "https://www.rollingstone.co.uk/...",
  "language": "English",
  "pageNumber": 1,
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}

How to scrape Rotten Tomatoes critic reviews

1. Open a Rotten Tomatoes title page.
2. Go to the Reviews tab.
3. Copy the URL.
4. Paste it into startUrls.
5. Select all-critics or top-critics.
6. Set maxItems to the review count you need.
7. Run the actor.
8. Export the dataset.

How to scrape Rotten Tomatoes audience reviews

Select all-audience to collect public audience reviews.

Select verified-audience when you only need reviews tagged as verified by Rotten Tomatoes / Fandango.

Audience reviews can include rating tokens, reviewer display names, verification status, spoiler flags, review text, and review dates.

Tips for better results

Use specific Rotten Tomatoes title URLs instead of search pages.

Run separate tasks for critic and audience monitoring when you want separate schedules.

Keep pageSize at 20 unless you have a reason to change it.

Use maxItems as your main budget control.

If a title has very few reviews, the actor will stop naturally when Rotten Tomatoes reports no next page.

Integrations

Send results to Google Sheets for PR reports.

Export CSV files for sentiment analysis in Python or R.

Connect the dataset to Make or Zapier for alerts when new reviews appear.

Use Apify webhooks to trigger downstream pipelines after each scheduled run.

Feed review text into LLM classification workflows for themes, sentiment, spoilers, or quote extraction.

API usage: Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rottentomatoes-reviews-scraper').call({
  startUrls: [{ url: 'https://www.rottentomatoes.com/m/oppenheimer_2023/reviews' }],
  reviewTypes: ['all-critics', 'all-audience'],
  maxItems: 100
});

console.log(run.defaultDatasetId);

API usage: Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/rottentomatoes-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.rottentomatoes.com/m/oppenheimer_2023/reviews'}],
    'reviewTypes': ['all-critics', 'all-audience'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])

API usage: cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~rottentomatoes-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.rottentomatoes.com/m/oppenheimer_2023/reviews"}],"reviewTypes":["all-critics"],"maxItems":50}'

MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP Server.

MCP URL:

https://mcp.apify.com/?tools=automation-lab/rottentomatoes-reviews-scraper

Claude Code setup:

$claude mcp add apify-rottentomatoes-reviews "https://mcp.apify.com/?tools=automation-lab/rottentomatoes-reviews-scraper"

Claude Desktop JSON config example:

{
  "mcpServers": {
    "apify-rottentomatoes-reviews": {
      "url": "https://mcp.apify.com/?tools=automation-lab/rottentomatoes-reviews-scraper"
    }
  }
}

Example prompts:

• "Scrape the latest Rotten Tomatoes critic reviews for this movie URL."
• "Collect verified audience reviews from these two Rotten Tomatoes pages and summarize sentiment themes."
• "Run the Rotten Tomatoes Reviews Scraper weekly and compare new review text against last week."

Scheduling and monitoring

Create an Apify task with your chosen URLs and review types.

Schedule it daily during launch week or weekly for long-tail reputation monitoring.

Use the dataset item timestamps and review dates to identify newly collected reviews.

Common workflows

Launch monitoring: scrape critic and audience tabs for a new release every day.

Awards tracking: collect critic quotes from films in contention and compare publication coverage.

Streaming performance: compare audience reviews for several TV seasons after a platform launch.

Reputation analysis: export review text to sentiment or topic models.

Competitive research: compare Rotten Tomatoes reaction across a slate of titles.

Limitations

The actor extracts public Rotten Tomatoes review data. It does not log in, bypass paywalls, or access private user data.

Rotten Tomatoes can change its page structure or API responses. If that happens, the actor may need an update.

Some titles have limited audience or critic reviews, so output volume depends on the target page.

Troubleshooting

If you receive no results, verify that the URL opens a Rotten Tomatoes reviews page in your browser.

If only critic reviews appear, check whether your maxItems limit was reached before the actor moved to audience tabs.

If audience pages return fewer items than requested, that is normal; Rotten Tomatoes may cap audience responses per page.

If a TV episode has no review tab, try the TV season reviews URL instead.

Legality

This actor extracts publicly available pages and review endpoints. You are responsible for using the data lawfully, respecting applicable terms, privacy rules, copyright, and database rights in your jurisdiction.

Do not republish copyrighted review text without permission. For many workflows, use snippets, analysis, internal reporting, or links back to the original sources.

FAQ

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

Yes. Select multiple reviewTypes, such as all-critics and all-audience, and set maxItems high enough to reach both tabs.

Why did my run return fewer reviews than my limit?

The actor stops when Rotten Tomatoes has no next page for the selected title and review type. Some titles simply have fewer public reviews.

Can I use title URLs instead of /reviews URLs?

Yes. The actor normalizes Rotten Tomatoes title URLs to their /reviews page before extracting metadata and review API cursors.

Related scrapers

Explore related actors by Automation Lab:

• https://apify.com/automation-lab/google-search-scraper
• https://apify.com/automation-lab/app-store-reviews-scraper
• https://apify.com/automation-lab/sitejabber-reviews-scraper
• https://apify.com/automation-lab/chrome-web-store-reviews-scraper

Support

If a Rotten Tomatoes URL fails or a field is missing, share the run URL and the input you used. Include whether you expected critic reviews, audience reviews, verified audience reviews, or all review tabs.

Changelog

Initial version extracts Rotten Tomatoes critic and audience review data from public review pages using HTTP requests and Rotten Tomatoes review API pagination.