# Rotten Tomatoes Scraper — Movies, TV, Ratings & Reviews (`haketa/rottentomatoes-scraper`) Actor

Scrape movies and TV shows from Rotten Tomatoes: Tomatometer, Popcornmeter (audience score), review & rating counts, synopsis, genres, cast, director, content rating and release year. Search, browse or paste URLs. Optional top critic reviews. No API key. Export JSON, CSV, Excel.

- **URL**: https://apify.com/haketa/rottentomatoes-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** AI, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Rotten Tomatoes Scraper 🍅🎬📺

Extract **movies and TV shows from Rotten Tomatoes** at scale — **Tomatometer, Popcornmeter (audience score), review & rating counts, synopsis, genres, cast, director, content rating and release year** — and export clean JSON, CSV or Excel. Search by title, browse whole categories, or paste any movie/TV URL.

Perfect for **film & TV datasets, recommendation engines, review analysis, entertainment market research and AI/LLM products.**

***

### 🔑 What this scraper does

- 🔎 **Search by title** — find any movie or TV show by name and scrape it in full.
- 🗂️ **Browse whole categories** — movies at home, in theaters, TV shows and more, paginated automatically.
- 🔗 **Paste URLs** — drop in any `/m/...` or `/tv/...` page and get structured data back.
- 🍅 **Tomatometer** — the critics' score, plus whether the title is **Certified Fresh**.
- 🍿 **Popcornmeter** — the audience score, alongside critic and rating counts.
- 🎭 **Full metadata** — synopsis, genres, director, cast, content rating and release year.
- 📺 **Movies *and* TV** — TV shows include the number of seasons.
- 📝 **Top critic reviews** (optional) — critic, publication, date and Fresh/Rotten sentiment (featured critic reviews on movie pages).

No login, no API key. Pick titles, press start, export.

***

### 📋 Example output

**Movie:**

```json
{
  "title": "Inception",
  "mediaType": "movie",
  "url": "https://www.rottentomatoes.com/m/inception",
  "tomatometer": 86,
  "tomatometerState": "Tomatometer",
  "tomatometerCertified": true,
  "audienceScore": 91,
  "audienceState": "Popcornmeter",
  "criticsReviewCount": 364,
  "audienceRatingCount": "250,000+ Ratings",
  "synopsis": "Dom Cobb (Leonardo DiCaprio) is a thief with the rare ability to enter people's dreams and steal their secrets from their subconscious...",
  "genres": ["Sci-Fi", "Mystery & Thriller", "Action"],
  "director": ["Christopher Nolan"],
  "cast": ["Leonardo DiCaprio", "Joseph Gordon-Levitt", "Elliot Page", "Tom Hardy", "Ken Watanabe"],
  "contentRating": "PG-13",
  "releaseYear": 2010,
  "numberOfSeasons": null,
  "poster": "https://resizing.flixster.com/.../p7825626_p_v10_ae.jpg",
  "scrapedAt": "2026-09-14T10:00:00.000Z"
}
```

**TV show (with optional reviews):**

```json
{
  "title": "The Last of Us",
  "mediaType": "tv",
  "url": "https://www.rottentomatoes.com/tv/the_last_of_us",
  "tomatometer": 94,
  "audienceScore": 62,
  "criticsReviewCount": 261,
  "numberOfSeasons": 2,
  "genres": ["Drama", "Adventure"],
  "topCriticsReviews": [
    { "critic": "Wendy Ide", "publication": "The Times (UK)", "date": "Mar 20, 2024", "sentiment": "POSITIVE", "criticUrl": "https://www.rottentomatoes.com/critic/wendy-ide" }
  ]
}
```

***

### 🗂️ Fields you get

| Field | Description |
|---|---|
| `title` | Movie / show title |
| `mediaType` | `movie` or `tv` |
| `url` | Rotten Tomatoes page URL |
| `tomatometer` | Critics' score (0–100) |
| `tomatometerState` | Score label (Tomatometer) |
| `tomatometerCertified` | Whether it's Certified Fresh (`true`/`false`) |
| `audienceScore` | Audience score, 0–100 (Popcornmeter) |
| `audienceState` | Score label (Popcornmeter) |
| `criticsReviewCount` | Number of critic reviews |
| `audienceRatingCount` | Number of audience ratings (as shown, e.g. "250,000+ Ratings") |
| `synopsis` | Plot summary |
| `genres` | List of genres |
| `director` | Director(s) |
| `cast` | Top billed cast |
| `contentRating` | Age/content rating (PG-13, TV-MA…) |
| `releaseYear` | Release year |
| `numberOfSeasons` | Seasons (TV only; `null` for movies) |
| `poster` | Poster image URL |
| `topCriticsReviews` | *(optional)* Top critic reviews: critic, publication, date, sentiment, profile link |
| `scrapedAt` | Scrape timestamp |

> Title, scores, counts, genres, cast, director, content rating and year come on every title. Synopsis is included where published. Turn on **Include top critic reviews** to add the featured critic reviews for each title.

***

### 🚀 How to use

1. Click **Try for free**.
2. Add **Search Queries** (movie/TV titles), and/or paste **Start URLs** (movie, TV, browse or search pages).
3. (Optional) Toggle **Include top critic reviews**.
4. Set **Max Items**, then click **Start**.
5. Export as **JSON, CSV, Excel, HTML, RSS**, or via the **Apify API**.

***

### 📝 Example inputs

#### 1. Search for specific titles

```json
{ "searchQueries": ["Dune Part Two", "Oppenheimer", "The Bear"] }
```

#### 2. Browse the most popular movies to stream

```json
{ "startUrls": ["https://www.rottentomatoes.com/browse/movies_at_home/sort:popular"], "maxItems": 200 }
```

#### 3. Browse top TV shows + include reviews

```json
{
  "startUrls": ["https://www.rottentomatoes.com/browse/tv_series_browse/sort:popular"],
  "includeReviews": true,
  "maxItems": 150
}
```

#### 4. Specific movie and TV URLs

```json
{
  "startUrls": [
    "https://www.rottentomatoes.com/m/inception",
    "https://www.rottentomatoes.com/tv/the_last_of_us"
  ]
}
```

#### 5. Movies in theaters

```json
{ "startUrls": ["https://www.rottentomatoes.com/browse/movies_in_theaters/sort:popular"], "maxItems": 100 }
```

***

### 💡 Popular use cases

#### 🎬 Build a movie & TV dataset

Assemble a structured catalogue of films and shows with critic and audience scores, genres, cast and release years — ready for analysis or a product.

#### 🧠 Recommendation & discovery engines

Power a recommender with Tomatometer, Popcornmeter, genres and cast relationships across thousands of titles.

#### 📈 Review & sentiment analysis

Track how critics and audiences score titles over time, compare Tomatometer vs. Popcornmeter gaps, and study genre or era trends.

#### 🎯 Entertainment market research

Benchmark a studio's or platform's catalogue, monitor new releases in theaters and at home, and map score distributions by genre.

#### 🤖 AI, LLM & data products

Feed clean, structured film/TV metadata and scores into your own models, dashboards, chatbots or apps.

***

### 👥 Who uses this

- **Data scientists & ML engineers** building film/TV datasets and recommenders.
- **Analysts & researchers** studying critic vs. audience reception and genre trends.
- **Entertainment & media teams** monitoring releases and catalogue performance.
- **Developers & AI builders** who need structured movie/TV data via API.

***

### 🎛️ Options

- **Search Queries** — movie/TV titles to find and scrape.
- **Start URLs** — movie, TV, browse or search URLs (browse pages paginate automatically).
- **Include top critic reviews** — add featured critic reviews per title.
- **Max Items** — cap total titles (`0` = unlimited).
- **Proxy** — Apify Proxy is enabled by default and just works.

***

### ❓ FAQ

**Do I need an account or API key?**
No. Add a title or URL and run — no login, no key.

**What is the difference between Tomatometer and Popcornmeter?**
The **Tomatometer** is the critics' score (percentage of positive professional reviews). The **Popcornmeter** is the audience score (based on verified audience ratings). Both are returned, 0–100.

**What does "Certified Fresh" mean?**
It's a special distinction for titles with a consistently high Tomatometer and enough reviews. The `tomatometerCertified` field tells you whether a title has it.

**Can I scrape both movies and TV shows?**
Yes. Movies come from `/m/...` pages and TV shows from `/tv/...` pages; `mediaType` tells them apart and TV shows include `numberOfSeasons`.

**What do the reviews include?**
With **Include top critic reviews** on, you get the featured critic reviews for each title: critic name, publication, date, Fresh/Rotten sentiment and the critic's profile link.

**How many titles can I scrape?**
As many as your search, URLs or browse pages return — a browse category holds dozens to a few hundred titles, so combine several categories or searches (and raise `maxItems`) for a larger dataset. Set `maxItems` to `0` for everything a run finds.

**What export formats are supported?**
JSON, CSV, Excel, HTML table, RSS, and the Apify API. Connect to Make, Zapier, Google Sheets, Slack, webhooks or an MCP server.

**Is the data structured and clean?**
Yes. Each title is a flat, typed JSON object, de-duplicated by URL, with scores parsed to numbers.

***

### 🔌 Integrations

- Export to **JSON, CSV, Excel, HTML, RSS**.
- Pull via the **Apify API** or client libraries (JavaScript, Python).
- Connect to **Make, Zapier, Google Sheets, Slack, webhooks** and more.
- Use from an **MCP server** in your AI agent / LLM workflow.
- Schedule recurring runs with the **Apify Scheduler** to track new releases.

***

### ⚖️ Legal & responsible use

This scraper collects **publicly available** information only — the same movie and TV data any visitor can see on Rotten Tomatoes without logging in. It does not access private accounts or anything behind authentication.

You are responsible for how you use the collected data. Please:

- Respect Rotten Tomatoes' Terms of Service and all applicable laws.
- Use scores, reviews and metadata lawfully and only for legitimate purposes.
- Attribute scores and reviews to Rotten Tomatoes and the original critics/publications where you display them.
- Avoid excessive request rates and scrape responsibly.

This tool is provided for lawful purposes such as research, analysis and building data products. It is not affiliated with, endorsed by, or connected to Rotten Tomatoes or Fandango.

# Actor input Schema

## `searchQueries` (type: `array`):

Movie or TV titles to search for on Rotten Tomatoes, e.g. "Dune Part Two", "The Last of Us". Each match is scraped in full.

## `startUrls` (type: `array`):

Optional. Paste Rotten Tomatoes URLs: a movie (/m/...), a TV show (/tv/...), a browse page (/browse/movies\_at\_home/...) or a search page (/search?search=...). Browse pages are paginated automatically.

## `includeReviews` (type: `boolean`):

Also collect the top critic reviews shown on each title (critic, publication, date, Fresh/Rotten sentiment and profile link).

## `maxItems` (type: `integer`):

Maximum number of titles to scrape. 0 = unlimited.

## `proxyConfiguration` (type: `object`):

Datacenter proxy works out of the box; US residential is used automatically as a fallback when needed.

## Actor input object example

```json
{
  "searchQueries": [
    "Dune Part Two"
  ],
  "startUrls": [],
  "includeReviews": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view and export all scraped titles (JSON, CSV, Excel).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "Dune Part Two"
    ],
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/rottentomatoes-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["Dune Part Two"],
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/rottentomatoes-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "Dune Part Two"
  ],
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/rottentomatoes-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/rottentomatoes-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5j4s2ybr7d6XTgWfl/builds/7oiLMSHYDRtZRu3d7/openapi.json