# IMDb Scraper (`solidcode/imdb-scraper`) Actor

\[💰 $5.0 / 1K] Extract movie & TV data from IMDb — ratings, vote counts, cast, directors, genres, runtime, certificates, plot, and release year. Search by title, paste IMDb URLs, or browse the catalog by genre, year, and rating. Optional user reviews per title.

- **URL**: https://apify.com/solidcode/imdb-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

Learn more: https://docs.apify.com/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

## IMDb Scraper

Pull movie and TV data from IMDb at scale — ratings with vote counts, full cast and crew, genres, runtime, content certificates, plots, country of origin, posters, and optional user reviews. Search by title, paste IMDb URLs, or browse the entire catalog with type, genre, year, and rating filters. Built for data analysts, media and entertainment researchers, and app and catalog builders who need clean, structured IMDb data without collecting it title by title.

### Why This Scraper?

- **Three ways in, one dataset** — search by title name, paste IMDb title URLs or bare `tt…` IDs, or browse the full IMDb catalog with advanced filters. Mix all three in a single run.
- **9 title types, 22 genres** — narrow a catalog browse to movies, TV series, TV movies, TV episodes, mini-series, TV specials, shorts, or video games, across genres from Action and Sci-Fi to Film-Noir, Documentary, and Western.
- **Curated catalog browsing** — combine a release-year range, a minimum IMDb rating (0–10), and a sort order (popularity, IMDb rating, vote count, newest release, or A–Z) to build exactly the list you want.
- **Ratings with vote counts on every title** — the IMDb aggregate rating *and* the total number of votes, so you can weight a 9.2 from 2 million voters differently from a 9.2 from 200.
- **Full credits per title** — directors, writers, and top-billed cast, plus content certificate (e.g. PG-13), runtime, country of origin, poster image, and plot synopsis.
- **Up to 500 user reviews per title** — opt in to pull each review with its rating, headline, author, date, helpfulness votes, and full text, returned as separate review records keyed back to the title.
- **Batch input** — feed many search terms or many URLs at once; each one runs to its own result cap.
- **10 interface languages** — request titles and text in English, Spanish, French, German, Italian, Portuguese, Hindi, Japanese, Korean, or Chinese where IMDb provides them.

### Use Cases

**Market Research & Competitive Analysis**
- Benchmark a studio's catalog by rating and vote count against rival releases
- Track how a genre's average rating shifts across release decades
- Size the back-catalog of a streaming acquisition target by title type

**Media & Entertainment Analytics**
- Build rating-vs-vote-count datasets to model audience reception
- Compare critical reception across countries of origin
- Surface the highest-rated titles in a genre for editorial round-ups

**App & Catalog Building**
- Seed a movie or TV recommendation app with structured title metadata
- Populate a watchlist product with posters, runtimes, and certificates
- Keep a media catalog fresh with ratings and new releases

**Academic & Cultural Research**
- Study representation trends by country of origin across a year range
- Analyze runtime or certificate distributions over time
- Mine user reviews for sentiment and reception studies

**Content & SEO Teams**
- Generate "best of the decade" lists backed by real ratings and vote counts
- Pull plot summaries and credits to enrich movie and TV articles
- Source quotable user reviews for engagement features

### Getting Started

#### Simple Title Search

The simplest run — one title name, the default 50 results:

```json
{
    "searchTerms": ["The Godfather"]
}
````

#### Specific Titles by URL or ID

Pull full details for an exact set of titles — paste IMDb URLs or bare `tt…` IDs:

```json
{
    "startUrls": [
        "https://www.imdb.com/title/tt0068646/",
        "tt0468569"
    ]
}
```

#### Advanced Filtered Browse with Reviews

Build a curated list — top-rated drama and crime movies from the 1990s, sorted by IMDb rating, with the 10 most relevant reviews per title:

```json
{
    "useAdvancedFilters": true,
    "titleType": "feature",
    "genres": ["drama", "crime"],
    "releaseYearMin": 1990,
    "releaseYearMax": 1999,
    "ratingMin": 8,
    "sortBy": "rating",
    "maxResults": 100,
    "maxReviewsPerTitle": 10
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["The Godfather"]` | Movie or TV show names to search for. Each term returns its matching titles. Leave empty if using URLs or advanced filters. |
| `startUrls` | string\[] | `[]` | IMDb title URLs (e.g. `https://www.imdb.com/title/tt0068646/`) or bare IMDb IDs like `tt0068646`, for pulling full details on specific titles. |

#### Advanced Filters

These apply only when `useAdvancedFilters` is on.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `useAdvancedFilters` | boolean | `false` | Browse IMDb's full title catalog with the filters below instead of, or in addition to, search terms. |
| `titleType` | string | `"feature"` | Restrict results to one kind of title: Movie, TV Series, TV Movie, TV Episode, TV Mini-Series, TV Special, Short, Video Game, or Any type. |
| `genres` | string\[] | `[]` | Only include titles in these genres. Choose from 22 IMDb genres (Action, Comedy, Drama, Film-Noir, Sci-Fi, …). Empty means all genres. |
| `releaseYearMin` | integer | null | Only include titles released in or after this year. |
| `releaseYearMax` | integer | null | Only include titles released in or before this year. |
| `ratingMin` | integer | null | Only include titles with an IMDb rating at or above this value (0–10). |
| `sortBy` | string | `"popularity"` | Order results by Popularity, IMDb Rating, Number of Votes, Release Date (newest), or Title (A–Z). |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Maximum titles per search term or filter set. Set to `0` for as many as available. |
| `maxReviewsPerTitle` | integer | `0` | Also collect up to this many user reviews per title (capped at 500). `0` skips reviews. Keep it low (10–50) on popular titles to control cost. |
| `language` | string | `"en"` | Preferred language for IMDb titles and text where available. English, Spanish, French, German, Italian, Portuguese, Hindi, Japanese, Korean, or Chinese. |

### Output

Every row carries a `recordType` field — `title` or `review` — so you can filter cleanly downstream. Review rows are emitted only when `maxReviewsPerTitle` is greater than `0`, and each one carries the parent title's `imdbId` as a foreign key.

#### Title (`recordType: "title"`)

```json
{
    "recordType": "title",
    "imdbId": "tt0068646",
    "title": "The Godfather",
    "originalTitle": "The Godfather",
    "titleType": "movie",
    "year": "1972",
    "rating": 9.2,
    "ratingCount": 2089456,
    "certificate": "R",
    "runtime": "2h 55min",
    "genres": ["Crime", "Drama"],
    "director": "Francis Ford Coppola",
    "writers": ["Mario Puzo", "Francis Ford Coppola"],
    "stars": ["Marlon Brando", "Al Pacino", "James Caan"],
    "country": "United States",
    "description": "The aging patriarch of an organized crime dynasty transfers control of his clandestine empire to his reluctant son.",
    "image": "https://m.media-amazon.com/images/M/MV5B...._V1_.jpg",
    "url": "https://www.imdb.com/title/tt0068646/"
}
```

**Core fields**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"title"` |
| `imdbId` | string | Canonical IMDb ID (`tt…`) |
| `title` | string | Display title |
| `originalTitle` | string | Original-language title, when it differs from the display title |
| `titleType` | string | IMDb's own type label — `movie`, `tvSeries`, `tvMiniSeries`, `short`, etc. (a `feature` filter returns `movie`) |
| `year` | string | Release year, or a range like `"2008–2013"` for a series |
| `url` | string | Canonical IMDb title URL |

**Ratings**

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | IMDb aggregate rating, 0–10 (null if unrated) |
| `ratingCount` | number | Total number of votes behind the rating |
| `certificate` | string | Content certificate (e.g. `PG-13`, `R`, `TV-MA`); null when unrated |

**Credits & details**

| Field | Type | Description |
|-------|------|-------------|
| `runtime` | string | Human-readable runtime, e.g. `"2h 55min"` |
| `genres` | string\[] | List of genres |
| `director` | string | Director(s), comma-joined |
| `writers` | string\[] | Credited writers |
| `stars` | string\[] | Top-billed cast |
| `country` | string | Country or countries of origin |
| `description` | string | Plot synopsis |
| `image` | string | Poster image URL (null when IMDb has no poster) |

#### Review (`recordType: "review"`)

Emitted only when `maxReviewsPerTitle` is greater than `0`. Capped at 500 per title.

```json
{
    "recordType": "review",
    "imdbId": "tt0068646",
    "reviewTitle": "A masterpiece of American cinema",
    "reviewText": "From the opening wedding sequence to the final closing door, every frame is purposeful...",
    "reviewRating": 10,
    "author": "filmlover_1972",
    "date": "2019-03-14",
    "helpfulVotes": 487,
    "url": "https://www.imdb.com/review/rw1234567/"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` |
| `imdbId` | string | Parent title's IMDb ID — join reviews back to their title |
| `reviewTitle` | string | Review headline |
| `reviewText` | string | Full review body |
| `reviewRating` | number | Reviewer's score, 1–10 (null if none given) |
| `author` | string | Reviewer's username |
| `date` | string | Review submission date |
| `helpfulVotes` | number | How many users found the review helpful |
| `url` | string | Permalink to the review on IMDb |

### Tips for Best Results

- **Pick the input mode that fits the job.** Search terms are best for known titles, URLs and IDs for an exact set, and advanced filters for discovering titles you don't yet know by name.
- **Combine the year range and minimum rating to build a curated "best of decade" list.** Set `releaseYearMin`/`releaseYearMax` to the decade, `ratingMin` to 8, and `sortBy` to `rating` for an instant ranked shortlist.
- **Enable reviews only on the handful of titles you truly care about.** Each review is returned as its own result, so a blockbuster with thousands of reviews can balloon a run — keep `maxReviewsPerTitle` at 10–50 unless you specifically need the full review set.
- **Use `sortBy: "votes"` to find the most-discussed titles**, not just the highest-rated — a niche film can score 9.0 from a few hundred voters, while vote count reveals mainstream reach.
- **Set `maxResults` to `0` only with tight filters.** An unfiltered catalog browse is enormous; pair `0` with a specific genre, year range, and title type to keep the run focused.
- **Lean on `titleType` for clean datasets.** Restricting to `feature` or `tv_series` keeps episodes and shorts out of a movie-level analysis.
- **Set the `language` to localize titles** when building a catalog for a specific regional audience.

### Pricing

**From $5.00 per 1,000 results** — undercutting the typical market rate for IMDb extraction while bundling ratings, full credits, and optional reviews at no extra charge. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.54 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.35 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.50 | $50.00 |
| 100,000 | $600.00 | $565.00 | $535.00 | $500.00 |

No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. A "result" is any row in the output dataset, so each user review you collect counts as a separate result: a run with reviews enabled returns more billable results than a titles-only run. Keep `maxReviewsPerTitle` modest if you want a predictable, titles-first cost.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, media analytics, catalog building, and academic study. Users are responsible for complying with applicable laws and IMDb's terms of service, including making reasonable-rate requests and respecting content usage rules. Treat user reviews and any personal data with care, and do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

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

Movie or TV show names to search for on IMDb, such as 'The Godfather' or 'Breaking Bad'. Each term returns its matching titles. Leave empty if using title URLs or advanced filters.

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

Paste IMDb title URLs (e.g. https://www.imdb.com/title/tt0068646/) to pull full details for specific movies or shows. Also accepts bare IMDb IDs like 'tt0068646'.

## `useAdvancedFilters` (type: `boolean`):

Browse IMDb's advanced title catalog using the filters below (type, genre, year, rating) instead of (or in addition to) search terms. Turn this on to run a filtered catalog search.

## `titleType` (type: `string`):

Limit advanced-filter results to a single kind of title. Only used when 'Use Advanced Filters' is enabled.

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

Only include titles in these genres. Leave empty for all genres. Used only with advanced filters.

## `releaseYearMin` (type: `integer`):

Only include titles released in or after this year. Leave empty for no lower bound.

## `releaseYearMax` (type: `integer`):

Only include titles released in or before this year. Leave empty for no upper bound.

## `ratingMin` (type: `integer`):

Only include titles with an IMDb rating at or above this value (0–10). Leave empty for no rating filter.

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

Order in which advanced-filter results are collected.

## `maxResults` (type: `integer`):

Maximum number of titles to return per search term or filter set. Set to 0 for as many as available. Each title returned is charged separately.

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

Also collect up to this many user reviews for each title (capped at 500 per title). Set to 0 to skip reviews (default). Popular titles can have thousands of reviews — keep this low (e.g. 10–50) to control cost, as each review is charged as a result.

## `language` (type: `string`):

Preferred language for IMDb titles and text where available.

## Actor input object example

```json
{
  "searchTerms": [
    "The Godfather"
  ],
  "startUrls": [],
  "useAdvancedFilters": false,
  "titleType": "feature",
  "genres": [],
  "sortBy": "popularity",
  "maxResults": 50,
  "maxReviewsPerTitle": 0,
  "language": "en"
}
```

# Actor output Schema

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

Table of titles with key fields like name, year, rating, votes, and genres.

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

Full per-title detail rows including cast, director, writers, plot, certificate, country, and poster image.

# 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 = {
    "searchTerms": [
        "The Godfather"
    ],
    "startUrls": [],
    "useAdvancedFilters": false,
    "titleType": "feature",
    "genres": [],
    "sortBy": "popularity",
    "maxResults": 50,
    "maxReviewsPerTitle": 0,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/imdb-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 = {
    "searchTerms": ["The Godfather"],
    "startUrls": [],
    "useAdvancedFilters": False,
    "titleType": "feature",
    "genres": [],
    "sortBy": "popularity",
    "maxResults": 50,
    "maxReviewsPerTitle": 0,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/imdb-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 '{
  "searchTerms": [
    "The Godfather"
  ],
  "startUrls": [],
  "useAdvancedFilters": false,
  "titleType": "feature",
  "genres": [],
  "sortBy": "popularity",
  "maxResults": 50,
  "maxReviewsPerTitle": 0,
  "language": "en"
}' |
apify call solidcode/imdb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IMDb Scraper",
        "description": "[💰 $5.0 / 1K] Extract movie & TV data from IMDb — ratings, vote counts, cast, directors, genres, runtime, certificates, plot, and release year. Search by title, paste IMDb URLs, or browse the catalog by genre, year, and rating. Optional user reviews per title.",
        "version": "1.0",
        "x-build-id": "Odc608Ux57srXS2a4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~imdb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-imdb-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/solidcode~imdb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-imdb-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/solidcode~imdb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-imdb-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Movie or TV show names to search for on IMDb, such as 'The Godfather' or 'Breaking Bad'. Each term returns its matching titles. Leave empty if using title URLs or advanced filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "IMDb Title URLs",
                        "type": "array",
                        "description": "Paste IMDb title URLs (e.g. https://www.imdb.com/title/tt0068646/) to pull full details for specific movies or shows. Also accepts bare IMDb IDs like 'tt0068646'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "useAdvancedFilters": {
                        "title": "Use Advanced Filters",
                        "type": "boolean",
                        "description": "Browse IMDb's advanced title catalog using the filters below (type, genre, year, rating) instead of (or in addition to) search terms. Turn this on to run a filtered catalog search.",
                        "default": false
                    },
                    "titleType": {
                        "title": "Title Type",
                        "enum": [
                            "feature",
                            "tv_series",
                            "tv_movie",
                            "tv_episode",
                            "tv_miniseries",
                            "tv_special",
                            "short",
                            "video_game",
                            "any"
                        ],
                        "type": "string",
                        "description": "Limit advanced-filter results to a single kind of title. Only used when 'Use Advanced Filters' is enabled.",
                        "default": "feature"
                    },
                    "genres": {
                        "title": "Genres",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include titles in these genres. Leave empty for all genres. Used only with advanced filters.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "action",
                                "adventure",
                                "animation",
                                "biography",
                                "comedy",
                                "crime",
                                "documentary",
                                "drama",
                                "family",
                                "fantasy",
                                "film_noir",
                                "history",
                                "horror",
                                "music",
                                "musical",
                                "mystery",
                                "romance",
                                "sci_fi",
                                "sport",
                                "thriller",
                                "war",
                                "western"
                            ],
                            "enumTitles": [
                                "Action",
                                "Adventure",
                                "Animation",
                                "Biography",
                                "Comedy",
                                "Crime",
                                "Documentary",
                                "Drama",
                                "Family",
                                "Fantasy",
                                "Film-Noir",
                                "History",
                                "Horror",
                                "Music",
                                "Musical",
                                "Mystery",
                                "Romance",
                                "Sci-Fi",
                                "Sport",
                                "Thriller",
                                "War",
                                "Western"
                            ]
                        },
                        "default": []
                    },
                    "releaseYearMin": {
                        "title": "Release Year From",
                        "minimum": 1870,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include titles released in or after this year. Leave empty for no lower bound."
                    },
                    "releaseYearMax": {
                        "title": "Release Year To",
                        "minimum": 1870,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include titles released in or before this year. Leave empty for no upper bound."
                    },
                    "ratingMin": {
                        "title": "Minimum IMDb Rating",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include titles with an IMDb rating at or above this value (0–10). Leave empty for no rating filter."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "popularity",
                            "rating",
                            "votes",
                            "release_date",
                            "alpha"
                        ],
                        "type": "string",
                        "description": "Order in which advanced-filter results are collected.",
                        "default": "popularity"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of titles to return per search term or filter set. Set to 0 for as many as available. Each title returned is charged separately.",
                        "default": 50
                    },
                    "maxReviewsPerTitle": {
                        "title": "User Reviews Per Title",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Also collect up to this many user reviews for each title (capped at 500 per title). Set to 0 to skip reviews (default). Popular titles can have thousands of reviews — keep this low (e.g. 10–50) to control cost, as each review is charged as a result.",
                        "default": 0
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "hi",
                            "ja",
                            "ko",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Preferred language for IMDb titles and text where available.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
