# Rotten Tomatoes Scraper (`jungle_synthesizer/rotten-tomatoes-scraper`) Actor

Extract Tomatometer and audience scores, cast, directors, genres, synopsis, and more from Rotten Tomatoes movie and TV show pages. Provide direct URLs to scrape specific titles.

- **URL**: https://apify.com/jungle\_synthesizer/rotten-tomatoes-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Movie & TV Show Scraper

Scrape movie and TV show data from [Rotten Tomatoes](https://www.rottentomatoes.com). Returns Tomatometer and audience scores, certification status, cast, directors, genres, synopsis, content rating, and release date — everything the RT detail page carries, in clean JSON.

---

### What Data Does It Return?

Each record covers one title. Movies and TV shows follow the same schema.

```json
{
  "url": "https://www.rottentomatoes.com/m/oppenheimer_2023",
  "title": "Oppenheimer",
  "type": "Movie",
  "tomatometer_score": "93%",
  "tomatometer_sentiment": "POSITIVE",
  "tomatometer_certified": true,
  "audience_score": "91%",
  "audience_sentiment": "POSITIVE",
  "audience_review_count": 6024,
  "synopsis": "Written and directed by Christopher Nolan...",
  "rating": "R",
  "genres": "Biography, History, Drama",
  "release_date": "Jul 21, 2023",
  "runtime": "PT3H",
  "cast": "Cillian Murphy, Emily Blunt, Matt Damon, Robert Downey Jr.",
  "directors": "Christopher Nolan",
  "ems_id": "07d7f9a2-3fa1-342a-b6ca-27fd594e04c6",
  "scraped_at": "2026-06-04T15:00:00.000Z"
}
````

| Field | Type | Description |
|-------|------|-------------|
| `url` | String | Rotten Tomatoes URL of the title |
| `title` | String | Title of the movie or TV show |
| `type` | String | Content type: `Movie` or `TvSeries` |
| `tomatometer_score` | String | Critics score as a percentage (e.g. `93%`) |
| `tomatometer_sentiment` | String | `POSITIVE` or `NEGATIVE` |
| `tomatometer_certified` | Boolean | Whether the title has Certified Fresh status |
| `audience_score` | String | Audience Popcornmeter score as a percentage |
| `audience_sentiment` | String | `POSITIVE` or `NEGATIVE` |
| `audience_review_count` | Number/String | Number of audience ratings |
| `synopsis` | String | Plot description |
| `rating` | String | MPAA or TV content rating (e.g. `R`, `TV-MA`) |
| `genres` | String | Comma-separated list of genres |
| `release_date` | String | Release date string |
| `runtime` | String | ISO 8601 duration (e.g. `PT3H`) or null |
| `cast` | String | Top cast members, comma-separated |
| `directors` | String | Directors (movies) or creators (TV shows) |
| `ems_id` | String | Rotten Tomatoes internal EMS identifier |
| `scraped_at` | String | ISO timestamp of when the record was scraped |

***

### Who Uses This?

- **Researchers and analysts** — building datasets of critic vs. audience score divergence across genres or eras
- **Recommendation engines** — enriching title metadata with quality signals beyond IMDb ratings
- **Entertainment journalists** — tracking score trends for new releases or historical titles
- **Data aggregators** — combining RT scores with streaming availability or box office data

***

### How Rotten Tomatoes Scraper Works

1. You provide a list of RT movie or TV show URLs
2. The scraper fetches each page using an HTTP crawler with Chrome fingerprinting
3. Scores are extracted from server-rendered JSON embedded in the page — no JavaScript execution needed
4. Each record is saved to the dataset in the schema above

***

### Input

```json
{
  "urls": [
    "https://www.rottentomatoes.com/m/oppenheimer_2023",
    "https://www.rottentomatoes.com/tv/breaking_bad",
    "https://www.rottentomatoes.com/m/the_godfather"
  ],
  "maxItems": 50
}
```

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `urls` | Array | Yes | — | List of Rotten Tomatoes movie (`/m/`) or TV show (`/tv/`) URLs |
| `maxItems` | Integer | No | 10 | Maximum records to return. `0` = no limit |

Movie URLs follow the pattern `/m/<slug>`. TV show URLs follow `/tv/<slug>`. Both work.

***

### FAQ

#### Does it handle both movies and TV shows?

Yes. The scraper detects the content type from the URL and extracts the correct score block for each. Movies embed scores in `reviewsData`; TV shows use `mediaScorecard`. The output schema is the same either way.

#### Does it need a proxy?

No. Rotten Tomatoes pages are served without Cloudflare challenge or aggressive bot detection. The scraper uses Chrome TLS fingerprinting which passes passive checks cleanly.

#### How do I find the URL for a specific title?

Navigate to the title on Rotten Tomatoes and copy the URL from your browser. Movie pages are at `rottentomatoes.com/m/<slug>`, TV series at `rottentomatoes.com/tv/<slug>`.

#### What's the difference between Tomatometer and audience score?

Tomatometer is the critic aggregation (percentage of positive reviews from approved critics). The audience score (Popcornmeter) is based on verified ratings from users who watched the title. Both are included, along with certification status for Certified Fresh titles.

***

### Need More Features?

Open a request on the [Apify Store listing](https://apify.com/orbtop/rotten-tomatoes-scraper) to suggest features like bulk URL import, season-level TV data, or review text extraction.

### Why Use Rotten Tomatoes Scraper?

- **Clean schema** — scores, sentiment, certification, and metadata in one flat record per title
- **No proxy required** — Rotten Tomatoes serves data without CF challenges; runs cheap on datacenter
- **Works for both content types** — movies and TV shows in a single actor, same output shape

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `urls` (type: `array`):

List of Rotten Tomatoes movie or TV show URLs to scrape (e.g. https://www.rottentomatoes.com/m/oppenheimer\_2023 or https://www.rottentomatoes.com/tv/breaking\_bad)

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

Maximum number of records to scrape. 0 = no limit.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "urls": [
    "https://www.rottentomatoes.com/m/oppenheimer_2023",
    "https://www.rottentomatoes.com/tv/breaking_bad"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "urls": [
        "https://www.rottentomatoes.com/m/oppenheimer_2023",
        "https://www.rottentomatoes.com/tv/breaking_bad"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/rotten-tomatoes-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "urls": [
        "https://www.rottentomatoes.com/m/oppenheimer_2023",
        "https://www.rottentomatoes.com/tv/breaking_bad",
    ],
    "maxItems": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "urls": [
    "https://www.rottentomatoes.com/m/oppenheimer_2023",
    "https://www.rottentomatoes.com/tv/breaking_bad"
  ],
  "maxItems": 10
}' |
apify call jungle_synthesizer/rotten-tomatoes-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/rotten-tomatoes-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rotten Tomatoes Scraper",
        "description": "Extract Tomatometer and audience scores, cast, directors, genres, synopsis, and more from Rotten Tomatoes movie and TV show pages. Provide direct URLs to scrape specific titles.",
        "version": "0.1",
        "x-build-id": "hrJddYLqoTqOuYERk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~rotten-tomatoes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-rotten-tomatoes-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~rotten-tomatoes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-rotten-tomatoes-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~rotten-tomatoes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-rotten-tomatoes-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "urls": {
                        "title": "Rotten Tomatoes URLs",
                        "type": "array",
                        "description": "List of Rotten Tomatoes movie or TV show URLs to scrape (e.g. https://www.rottentomatoes.com/m/oppenheimer_2023 or https://www.rottentomatoes.com/tv/breaking_bad)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of records to scrape. 0 = no limit."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
