# Rotten Tomatoes Scraper: Tomatometer & Audience Scores (`recordsdata/rotten-tomatoes-scraper`) Actor

Scrape Rotten Tomatoes: Tomatometer and audience scores, certified-fresh flags, browse lists and title details with cast, director and genres for movies and TV. Export CSV, Excel, JSON. No login or API key. Browse rows return about 29 titles per page.

- **URL**: https://apify.com/recordsdata/rotten-tomatoes-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** Videos, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3" alt="RecordsData" width="100%" />
</p>

## Rotten Tomatoes Scraper: Tomatometer, Audience & Cast

> **Rotten Tomatoes Scraper extracts Tomatometer and audience scores, certified-fresh flags, runtime, cast, crew, box office, streaming providers and critic and audience review quotes from rottentomatoes.com for movies and TV shows. Browse lists with genre, rating and streaming filters, keyword search, title URLs, or a monitor mode that returns only new titles. Up to 73 content fields per title, CSV, Excel, JSON or XML, no login, no API key. Verified against the live site on 2026-10-10. Priced from $10 per 1,000 browse rows and from $10.50 per 1,000 detail records.**

Rotten Tomatoes Scraper turns the Tomatometer (critics) and the audience score into a dataset. One browse page returns 28 titles in a single request, a detail record adds up to 73 content fields from the title page, and an optional review module adds critic and audience review rows.

### 🍅 What does Rotten Tomatoes Scraper do?

- Scrape the **Rotten Tomatoes browse lists** (movies at home, in theaters, coming soon, TV series) with 8 sort orders.
- Filter the list by **genre** (38 values), Tomatometer status (Certified Fresh, Fresh, Rotten), Popcornmeter status, content rating and streaming service. Rotten Tomatoes applies these itself.
- Keep only titles from a **release year range**, applied by the Actor; filtered-out titles are never charged.
- **Search by keyword** (up to 25 terms, for example `dune`): each term returns the best matching movies and TV shows as full detail records. Matching uses the public Wikidata catalogue.
- Fetch **full title details** from any movie, TV show or season URL such as `/tv/the_simpsons/s01`.
- Add **review rows** (optional): critic quotes with outlet, critic name, rating and link, and audience reviews with stars and verified flag.
- Run in **monitor mode** (`onlyNew`): schedule the same search and receive only titles not delivered by earlier runs.

Not delivered: the full review list of a title (hundreds of reviews). Rotten Tomatoes serves only up to 6 critic and 6 audience reviews on a public title page. Audience reviewer names are never collected.

### 📊 What data can you extract from Rotten Tomatoes?

A detail row carries up to 73 content fields; 76 dataset keys in total with `error`, `errorType` and `hint`. A field appears only when the page has it, so there are no always-empty columns.

| Group | Fields |
|---|---|
| Identity | `recordType`, `searchTerm`, `title`, `slug`, `url`, `mediaType`, `category`, `seasonNumber` |
| Critic scores | `tomatometer`, `criticsSentiment`, `certifiedFresh`, `criticReviewCount`, `criticAverageRating`, `freshCount`, `rottenCount`, `topCriticsScore`, `criticsConsensus` |
| Audience scores | `audienceScore`, `audienceSentiment`, `verifiedHot`, `audienceScoreAll`, `audienceScoreVerified`, `audienceReviewCount`, `audienceAverageRating`, `audienceSays` |
| Release | `contentRating`, `genres`, `releaseDate`, `releaseYear`, `releaseDateTheaters`, `releaseDateStreaming`, `availability` |
| Production | `runtime`, `runtimeMinutes`, `originalLanguage`, `directors`, `creators`, `producers`, `screenwriters`, `actors`, `distributor`, `network` |
| Box office and TV | `boxOffice`, `boxOfficeUsd`, `seasonCount`, `episodeCount`, `seasons`, `streamingProviders`, `description`, `scrapedAt` |
| Review rows | `reviewType`, `reviewerName`, `publication`, `topCritic`, `verifiedAudience`, `reviewDate`, `reviewRating`, `reviewText`, `reviewUrl` |

Browse rows carry the list fields. Numeric twins sit next to text values (`runtimeMinutes`, `boxOfficeUsd`). The Tomatometer reads `Not Scored` when a title has no critic score.

### 🧾 Rotten Tomatoes sample output

Detail record for a search on `dune`, trimmed (checked against the live page on 2026-10-10; a real row has more columns):

```json
{
  "recordType": "detail",
  "searchTerm": "dune",
  "title": "Dune (2021)",
  "mediaType": "movie",
  "tomatometer": 83,
  "criticReviewCount": 512,
  "audienceScore": 90,
  "runtime": "2h 35m",
  "contentRating": "PG-13",
  "directors": ["Denis Villeneuve"]
}
```

Browse row:

```json
{
  "recordType": "list-title",
  "title": "Resident Evil",
  "mediaType": "movie",
  "tomatometer": 96,
  "certifiedFresh": true,
  "audienceScore": 91,
  "url": "https://www.rottentomatoes.com/m/resident_evil_2026"
}
```

### 💰 How much does it cost to scrape Rotten Tomatoes?

Pay per event, only for saved rows. Error, "title not found" and "no match" rows and empty results are never charged.

| Event | What it covers | Free plan | Bronze | Silver | Gold and higher |
|---|---|---|---|---|---|
| Browse row | One title with scores and sentiments | $0.010 | $0.010 | $0.010 | $0.010 |
| Title detail | One full record (title URL or search match) | $0.012 | $0.0115 | $0.011 | $0.0105 |
| Review | One critic or audience review row | $0.0005 | $0.0005 | $0.0005 | $0.0005 |

Review rows are a flat $0.0005 each ($0.50 per 1,000) on every plan.

- 1,000 browse rows cost $10.
- 1,000 detail records cost $12 on the Free plan and $10.50 on Gold.
- A title with 5 reviews is 6 rows: one detail record ($0.012 on Free) plus 5 x $0.0005 = $0.0025 for the reviews, $0.0145 in total.
- A keyword search for `dune` returns up to 5 detail records, about $0.06 on the Free plan.
- A monitor run that finds nothing new costs $0.

### 🚀 How to scrape Rotten Tomatoes in 3 steps

1. Choose a category, sort and filters, or paste movie or TV URLs under "Title URLs", or type search terms.
2. Set **Max Items** (default 10). It counts every row type, browse, detail and review.
3. Click **Start**, then download the dataset as CSV, Excel, JSON or XML.

### ⚙️ Rotten Tomatoes Scraper input

| Field | Default | What it does |
|---|---|---|
| `includeBrowse` | `true` | Scrape the browse list; skipped when you give title URLs or search terms |
| `category` | `movies_at_home` | `movies_at_home`, `movies_in_theaters`, `movies_coming_soon`, `tv_series_browse` |
| `sortBy` | `popular` | `popular`, `newest`, `top_box_office`, `a_z`, `critic_highest`, `critic_lowest`, `audience_highest`, `audience_lowest` |
| `genres` | `[]` | 38 genres |
| `criticsFilter`, `audienceFilter` | any | Certified Fresh, Fresh, Rotten; Verified Hot, Hot, Stale |
| `contentRatings` | `[]` | G to NR for movies, TV-Y to TV-MA for TV |
| `streamingServices` | `[]` | 13 services, for movies at home and TV |
| `releaseYearFrom`, `releaseYearTo` | none | Year range, applied by the Actor |
| `maxPages` | `5` | Browse pages, 28 titles each; the site stops serving a list at about 112 to 140 titles |
| `titleUrls` | `[]` | Movie, TV or season URLs or paths for detail records |
| `searchTerms`, `maxSearchResults` | `[]`, `5` | Up to 25 keywords, matches per keyword (1 to 25) |
| `includeReviews`, `reviewTypes`, `maxReviewsPerTitle` | `false`, both, `5` | Review rows, critic and/or audience, 1 to 12 per title, $0.0005 per review |
| `onlyNew`, `stateKey`, `resetSeen` | `false` | Monitor mode: skip titles already delivered |
| `maxItems` | `10` | Row cap across all row types. Free Apify users are limited to 10 |

```json
{
  "includeBrowse": false,
  "searchTerms": ["dune"],
  "includeReviews": true,
  "reviewTypes": ["critic", "audience"],
  "maxReviewsPerTitle": 5,
  "maxItems": 20
}
```

A combination the site does not offer, such as top box office outside theaters, returns one free `invalid-input` row naming the allowed values.

### 📤 Rotten Tomatoes Scraper output

Three dataset views (overview, details, reviews). Row types are `list-title`, `detail` and `review`, set in `recordType`. A search that finds nothing returns one free `no-match` row. Error rows carry `errorType` (`invalid-input`, `not-found`, `request-failed`, `parse-failed`, `no-match`, `search-failed`). If Rotten Tomatoes blocks the request and nothing could be collected, the run fails with an error instead of reporting success.

### ⚖️ Rotten Tomatoes scraper vs alternatives

Public Apify Store pages read on 2026-10-10. "Not stated" means the listing does not show it.

| | This Actor | gio21 | fetch_cat |
|---|---|---|---|
| Keyword search | yes, via Wikidata | yes, site search | not stated in their listing |
| Browse lists and filters | 4 lists, 8 sorts, genre, rating, service | not stated in their listing | not stated in their listing |
| Individual reviews | up to 12 per title, $0.0005 each | counts only | full lists, 4 review types |
| Monitor mode (only new) | yes | none, use schedules | not stated in their listing |
| Title fields | up to 73 | 23 listed | about 25 listed |
| Price per 1,000 | $10 browse, $12 to $10.50 detail | $5 | $0.005 start plus $0.000028 per item |

We are not the cheapest: gio21 charges $5 per 1,000 titles, about half our rate, and fetch_cat is cheaper per review and returns complete review lists, which we cannot. We lead on browse lists, filters, depth of title fields and monitor mode. parseforge/rottentomatoes-scraper lists browse only at $19 in its header and $21 in its README. If you only need bare scores, a flat cheaper actor fits better.

### 💡 Use cases

Streaming guides, newsletters, analysts, studios tracking release reception (monitor mode on a schedule) and sentiment researchers use the scores, consensus text and review quotes.

### 🔌 Run Rotten Tomatoes Scraper via API and integrations

```bash
curl -X POST "https://api.apify.com/v2/acts/recordsdata~rotten-tomatoes-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"category":"movies_in_theaters","sortBy":"popular","maxItems":10}'
```

Use the Apify client for Node.js or Python, schedule runs, or connect to Zapier, Make, n8n or Google Sheets.

### 🛡️ Is it legal to scrape Rotten Tomatoes?

The Actor reads publicly visible pages at a polite rate and collects no personal data. Audience reviewer names are never collected. Review the Rotten Tomatoes terms of use and your local rules for your use case.

### 🤖 Rotten Tomatoes Scraper MCP server for AI agents

AI agents can call this Actor through the Apify MCP server at `https://mcp.apify.com?tools=RecordsData/rotten-tomatoes-scraper`. The URL loads only this Actor as a tool.

MCP client configuration (Claude Desktop, Cursor, VS Code):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=RecordsData/rotten-tomatoes-scraper"
    }
  }
}
```

Example agent prompt:

> Use the Rotten Tomatoes Scraper to find "dune", return the best matches with Tomatometer, audience score and runtime, and include 5 critic and audience reviews for each. Then list which one is certified fresh.

Tool description for agents: returns current Tomatometer, audience score, certified fresh flags, genres, cast, crew, box office and streaming providers from rottentomatoes.com, from a browse list with filters, a keyword search or title URLs, with optional review rows. It takes the same fields as the Input table above.

### ❓ Frequently asked questions

#### What is the difference between the Tomatometer and the audience score on Rotten Tomatoes?

The Tomatometer is the share of approved critics who gave a title a positive review, while the audience score is the share of viewer ratings that are positive. The Rotten Tomatoes Scraper returns both as separate numeric columns, `tomatometer` and `audienceScore`, plus critic and audience sentiment on browse rows, so you can compare critic and audience opinion side by side.

#### What does certified fresh mean in the Rotten Tomatoes Scraper?

Certified Fresh is the Rotten Tomatoes seal for consistently well-reviewed titles. The Rotten Tomatoes Scraper returns it as the boolean column `certifiedFresh`, true or false, on every browse row from rottentomatoes.com. Filter the dataset on that column, or set the Tomatometer status filter to Certified Fresh to list only those movies.

#### Why is audienceScore "Not Scored" in the Rotten Tomatoes Scraper?

The title has no audience score yet on rottentomatoes.com, which is common for movies still in theaters or not yet released. The Rotten Tomatoes Scraper reports the value as `Not Scored` instead of leaving a blank. The Tomatometer is reported the same way when a title has no critic score.

#### Can the Rotten Tomatoes Scraper scrape TV shows?

Yes. In the Rotten Tomatoes Scraper pick the "TV series" browse category, or paste `/tv/` URLs under Title URLs, including season paths such as `/tv/the_simpsons/s01`, to get detail records. Each row has `mediaType` set to `tv` or `movie`, so both can share one dataset, with scores, seasons, network and cast on detail rows.

#### Why did my Rotten Tomatoes Scraper run return 0 results?

An empty browse page, a year range that matches nothing, a search term without a match, or a title URL that does not exist returns no charged rows. Check that each URL is a real rottentomatoes.com `/m/` or `/tv/` page. If the site blocks the request and nothing is collected, the run fails with an error.

#### What happens if I send an empty or invalid input to the Rotten Tomatoes Scraper?

An invalid category or sort value is rejected by the Apify platform with a 400 error before any run starts. An empty input `{}` runs the defaults, which return 10 browse rows. A sort or filter the site does not offer returns one free `invalid-input` row naming the allowed values, and the run ends SUCCEEDED.

#### Do I need a Rotten Tomatoes account or API key to use the scraper?

No. The Rotten Tomatoes Scraper reads publicly visible rottentomatoes.com pages, so you need no Rotten Tomatoes account, login or API key. You only need an Apify account to run it and export the dataset as CSV, Excel, JSON or XML.

#### Can I try the Rotten Tomatoes Scraper for free?

Yes. Free Apify users get a 10-row preview per run of the Rotten Tomatoes Scraper, enough to check the Tomatometer, audience score and certified fresh columns. Paid plans unlock larger runs. On the Free plan a browse row costs $0.010 and a title detail $0.012.

#### Will I be charged for failed rows in the Rotten Tomatoes Scraper?

No. The Rotten Tomatoes Scraper charges only for saved browse, detail and review rows ($0.0005 per review). Error rows, "title not found" rows, "no match" rows and empty results are never billed. A maximum total charge stops the run cleanly when reached.

#### How does keyword search work in the Rotten Tomatoes Scraper?

Add up to 25 words under Search terms, for example `dune` or `the bear`. The Rotten Tomatoes Scraper looks them up in the public Wikidata catalogue, keeps films and series that carry a Rotten Tomatoes id, and fetches each match as a normal title page. Ranking is Wikidata's. Each row shows the `searchTerm` it came from.

#### How many reviews does the Rotten Tomatoes Scraper return per title?

Up to 12 per title: Rotten Tomatoes shows at most 6 critic and 6 audience reviews on a public title page, and the Rotten Tomatoes Scraper reads those. Turn on `includeReviews`, pick critic, audience or both, and set `maxReviewsPerTitle`. A series page shows none, so the latest scored season is read.

#### How does monitor mode work in the Rotten Tomatoes Scraper?

Turn on `onlyNew` and schedule the same search. The Rotten Tomatoes Scraper remembers the title paths it delivered in a named store in your account and skips them on later runs before counting or charging them. A second identical run returns 0 rows and charges $0. Use `stateKey` to keep separate memories and `resetSeen` to start again.

### 🔗 Want more entertainment and review data? Other RecordsData scrapers

- [Metacritic Scores Scraper](https://apify.com/RecordsData/metacritic-scores-scraper)
- [Steam Reviews Scraper](https://apify.com/RecordsData/steam-reviews-scraper)
- [Kitsu Anime Scraper](https://apify.com/RecordsData/kitsu-anime-scraper)

### 🆘 Support

Open the Issues tab on this Actor's page, or write to contact.punkrecordsdata@gmail.com. Custom solutions available on request.

Last updated: 2026-10-11

# Actor input Schema

## `includeBrowse` (type: `boolean`):

Scrape the Rotten Tomatoes browse list for the selected category, with Tomatometer and audience score per title. Turn off to fetch only the title URLs and search terms below. When you give title URLs or search terms and leave this box untouched in an API call, the browse list is skipped.

## `category` (type: `string`):

Rotten Tomatoes browse section to scrape: movies at home (streaming), movies in theaters, movies coming soon, or TV series.

## `sortBy` (type: `string`):

Order of the browse list. Top box office exists only for movies in theaters; audience sorts do not exist for movies coming soon.

## `genres` (type: `array`):

Only titles in these genres (Rotten Tomatoes matches any of the ones you pick). Leave empty for every genre.

## `criticsFilter` (type: `string`):

Only titles whose Tomatometer is Certified Fresh, Fresh or Rotten. Certified Fresh does not exist for TV series.

## `audienceFilter` (type: `string`):

Only titles whose audience score is Verified Hot, Hot or Stale. Not available for movies coming soon; Verified Hot does not exist for TV series.

## `contentRatings` (type: `array`):

Only titles with these age ratings. Movie ratings (G to NR/Unrated) apply to the movie categories, TV ratings (TV-Y to TV-MA) to TV series. Leave empty for every rating.

## `streamingServices` (type: `array`):

Only titles available on these services. Works for movies at home and TV series; the in-theaters and coming-soon lists have no service filter. Leave empty for every service.

## `releaseYearFrom` (type: `integer`):

Keep only titles released in or after this year. Rotten Tomatoes has no year filter, so the actor applies it to the list it receives: raise Max browse pages when you use it, and titles outside the range are never charged.

## `releaseYearTo` (type: `integer`):

Keep only titles released in or before this year. Same rules as Release year from.

## `maxPages` (type: `integer`):

How deep to go into the browse list: 28 titles per page. The run also stops at Max Items, and Rotten Tomatoes serves a limited depth per list (often 100 to 300 titles), so a higher value simply returns the whole list.

## `titleUrls` (type: `array`):

Movie, TV show or season URLs or paths (for example /m/oppenheimer_2023, https://www.rottentomatoes.com/tv/shogun_2024 or /tv/the_simpsons/s01) to fetch full detail records: scores, rating counts, critics consensus, runtime, cast and crew, network and streaming providers.

## `searchTerms` (type: `array`):

Words to look for, for example dune or the bear. Each term finds the best matching movies and TV shows (public Wikidata catalogue, up to 25 terms) and returns a full detail record for each match.

## `maxSearchResults` (type: `integer`):

How many matching titles to return for each search term, best match first.

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

Add review rows after each detail record (title URLs and search terms only). Uses the reviews Rotten Tomatoes shows on the title page: up to 6 critic and 6 audience reviews. TV series pages show none, so the latest scored season is used. Reviews count toward Max Items.

## `reviewTypes` (type: `array`):

Which reviews to return: critic reviews (outlet, critic, rating, quote, link) and/or audience reviews (text, stars, verified flag). Both by default. Audience reviewer names are never collected.

## `maxReviewsPerTitle` (type: `integer`):

Maximum review rows per title (1 to 12). With both types selected they alternate: critic, audience, critic, and so on.

## `onlyNew` (type: `boolean`):

Return only titles that earlier runs of the same search have not delivered yet (matched by title path). Titles already seen are skipped before they are counted or charged. Use it on a schedule to watch a list or a keyword.

## `stateKey` (type: `string`):

A label that keeps separate memories for runs with identical settings, for example two schedules of the same search. Leave empty to share one memory per search.

## `resetSeen` (type: `boolean`):

Clear the saved memory of this search before the run, so every title counts as new again.

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

Maximum number of rows to return across all row types: browse rows, detail rows and review rows (a title with 5 reviews is 6 rows). Free Apify users are limited to 10 rows; paid users can set up to 1,000,000.

## Actor input object example

```json
{
  "includeBrowse": true,
  "category": "movies_at_home",
  "sortBy": "popular",
  "genres": [],
  "criticsFilter": "",
  "audienceFilter": "",
  "contentRatings": [],
  "streamingServices": [],
  "maxPages": 5,
  "titleUrls": [],
  "searchTerms": [],
  "maxSearchResults": 5,
  "includeReviews": false,
  "reviewTypes": [
    "critic",
    "audience"
  ],
  "maxReviewsPerTitle": 5,
  "onlyNew": false,
  "resetSeen": false,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `details` (type: `string`):

Detail records with ratings counts, cast, crew and streaming

## `reviews` (type: `string`):

Critic and audience review rows

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "includeBrowse": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/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 = { "includeBrowse": True }

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/rotten-tomatoes-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 '{
  "includeBrowse": true
}' |
apify call recordsdata/rotten-tomatoes-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/rotten-tomatoes-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/wmAgHLHAsQjDelbC8/builds/KuKRBrZUU4CYglbnV/openapi.json