# Rotten Tomatoes Movies & Reviews Scraper (`fetch_cat/rotten-tomatoes-movies-reviews-scraper`) Actor

Scrape public Rotten Tomatoes movie metadata, ratings, critic reviews, and audience reviews from movie or review URLs.

- **URL**: https://apify.com/fetch\_cat/rotten-tomatoes-movies-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** News, Social media, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 item extracteds

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

### At a glance

- **Best for:** movie and TV review research, entertainment marketing, title monitoring, content planning, and media analytics.
- **Inputs:** Rotten Tomatoes title or review URLs, review type selection, review limit per title, audience-review toggle, and proxy settings.
- **Outputs:** title metadata rows plus critic, top critic, audience, or verified audience review rows.
- **Exports:** download CSV, JSON, Excel, XML, RSS, or use the Apify Dataset API.
- **Cost:** `$0.005` per run plus the `item` event for each saved metadata or review row.

### Ready-to-run examples

- [Dune Part Two scores and reviews](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper/examples/dune-part-two-scores-and-reviews) - collect title scores plus critic and audience review rows.
- [Oppenheimer top critic reviews](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper/examples/oppenheimer-top-critic-reviews) - focus on the top critic stream for one title.
- [Barbie verified audience reviews](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper/examples/barbie-verified-audience-reviews) - collect verified audience review samples.
- [Compare award movie reviews](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper/examples/compare-award-movie-reviews) - run multiple movie URLs in one small comparison task.
- [Toy Story critic and audience reviews](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper/examples/toy-story-critic-audience-reviews) - test both critic and audience output formats.

### What can it do?

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

- **Collect title metadata:** save title, media type, description, release data, runtime, rating, genres, directors, and cast when visible.
- **Export score data:** collect Tomatometer and audience scores plus available review counts.
- **Extract critic reviews:** save reviewer names, publications, excerpts, sentiment signals, dates, ratings, and source URLs.
- **Extract audience reviews:** save public audience review text, display names, star ratings, dates, and verified flags when available.
- **Compare title reactions:** run several Rotten Tomatoes URLs in one job and export normalized rows for analysis.
- **Use as a Rotten Tomatoes data workflow:** run from Apify API, export CSV/Excel/JSON, schedule monitoring, or expose the Actor to AI agents through Apify MCP.

### 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 support, and both title-level and review-level context.

### Output groups

| 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

The actor uses pay-per-event pricing.

You pay a $0.005 `start` fee per run and a tiered `item` fee for each saved dataset row.

A row can be a title metadata row or a review row. The standard BRONZE price is $0.000028206 per row, about $0.028 per 1,000 saved rows.

Use a low `maxReviewsPerTitle` value for a small first test.

Increase the limit when you are satisfied with the output format.

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

```text
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

| Setting | JSON key | What it does |
| --- | --- | --- |
| Rotten Tomatoes URLs | `startUrls` | Movie, TV, or review URLs to process. Review URLs are normalized back to their title page. |
| Review types | `reviewTypes` | Any combination of `critic`, `topCritic`, `audience`, and `verifiedAudience`. |
| Include audience reviews | `includeAudienceReviews` | Convenience toggle for including audience reviews in addition to selected critic streams. |
| Maximum reviews per title and type | `maxReviewsPerTitle` | Limit applied separately for each selected review type on each title. Two titles with critic and audience selected and a limit of 25 can return up to 100 review rows plus two metadata rows. |
| Proxy configuration | `proxyConfiguration` | Optional proxy settings. Direct HTTP requests are the default; enable Apify Proxy if your environment requires it. |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.rottentomatoes.com/m/toy_story" }
  ],
  "reviewTypes": ["critic", "audience"],
  "includeAudienceReviews": true,
  "maxReviewsPerTitle": 25,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Example output

```json
{
  "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 |
| --- | --- |
| `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 |
| `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:** confirm the output format before adding a larger title list.
- **Use a low review limit first:** audience streams can be large, so increase `maxReviewsPerTitle` gradually.
- **Choose only needed review types:** collecting fewer streams keeps runs faster and easier to review.
- **Use JSON for systems:** export JSON when sending records to another API, warehouse, or app.
- **Use CSV or Excel for review:** spreadsheet exports are easier for editorial and research workflows.

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

```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

```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

```bash
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 and AI agents

Use this actor through the official Apify MCP server when working in Claude Code, Claude Desktop, or other MCP-compatible tools.

MCP server URL:

```text
https://mcp.apify.com?tools=fetch_cat/rotten-tomatoes-movies-reviews-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com?tools=fetch_cat/rotten-tomatoes-movies-reviews-scraper
```

Claude Desktop or other MCP client configuration:

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

The default Apify MCP server can search and run Actors. The focused URL exposes only this Actor to clients that support tool-scoped MCP connections.

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 actors

Explore other Apify scrapers from the same publisher:

- [YouTube Video Details Scraper](https://apify.com/fetch_cat/youtube-video-details-scraper)
- [YouTube Comments Scraper](https://apify.com/fetch_cat/youtube-comments-scraper)
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper)

### Changelog

- 2026-07-02 - Feature: Added ready-to-run Rotten Tomatoes Movies & Reviews example tasks on the Apify Store (APIA-1155)

- 2026-07-02 - Feature: Launched Rotten Tomatoes Movies & Reviews Scraper on Apify Store (APIA-1151)
  - This actor is now publicly available on [Apify Store](https://apify.com/fetch_cat/rotten-tomatoes-movies-reviews-scraper).

#### 0.1

Initial version with Rotten Tomatoes title metadata, critic reviews, audience reviews, score fields, and review traceability.

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

# Actor input Schema

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

Add Rotten Tomatoes movie, TV, or reviews URLs. Review URLs are normalized back to their title page automatically.

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

Choose which public review streams to collect. Top critic and verified audience options filter the public critic/audience feeds.

## `includeAudienceReviews` (type: `boolean`):

Convenience switch that adds audience reviews even when the review type list only contains critic reviews.

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

Maximum number of reviews to save for each selected review type on each title. Metadata rows are always saved.

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

Optional Apify proxy settings. The default uses direct HTTP requests; enable Apify Proxy if your environment needs it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.rottentomatoes.com/m/toy_story"
    }
  ],
  "reviewTypes": [
    "critic",
    "audience"
  ],
  "includeAudienceReviews": true,
  "maxReviewsPerTitle": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.rottentomatoes.com/m/toy_story"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/rotten-tomatoes-movies-reviews-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 = { "startUrls": [{ "url": "https://www.rottentomatoes.com/m/toy_story" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/rotten-tomatoes-movies-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.rottentomatoes.com/m/toy_story"
    }
  ]
}' |
apify call fetch_cat/rotten-tomatoes-movies-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rotten Tomatoes Movies & Reviews Scraper",
        "description": "Scrape public Rotten Tomatoes movie metadata, ratings, critic reviews, and audience reviews from movie or review URLs.",
        "version": "0.1",
        "x-build-id": "ifhh4mudys973JHQY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~rotten-tomatoes-movies-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-rotten-tomatoes-movies-reviews-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/fetch_cat~rotten-tomatoes-movies-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-rotten-tomatoes-movies-reviews-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/fetch_cat~rotten-tomatoes-movies-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-rotten-tomatoes-movies-reviews-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Rotten Tomatoes movie or review URLs",
                        "type": "array",
                        "description": "Add Rotten Tomatoes movie, TV, or reviews URLs. Review URLs are normalized back to their title page automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "reviewTypes": {
                        "title": "Review types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose which public review streams to collect. Top critic and verified audience options filter the public critic/audience feeds.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "critic",
                                "topCritic",
                                "audience",
                                "verifiedAudience"
                            ],
                            "enumTitles": [
                                "Critic reviews",
                                "Top critic reviews",
                                "Audience reviews",
                                "Verified audience reviews"
                            ]
                        },
                        "default": [
                            "critic",
                            "audience"
                        ]
                    },
                    "includeAudienceReviews": {
                        "title": "Also include audience reviews",
                        "type": "boolean",
                        "description": "Convenience switch that adds audience reviews even when the review type list only contains critic reviews.",
                        "default": true
                    },
                    "maxReviewsPerTitle": {
                        "title": "Maximum reviews per title and type",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each selected review type on each title. Metadata rows are always saved.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. The default uses direct HTTP requests; enable Apify Proxy if your environment needs it.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```