# IMDb Scraper β Movies, TV, Ratings, Reviews & Cast API (`logiover/imdb-scraper`) Actor
Unofficial IMDb API powered by IMDb's own GraphQL β no key, no browser. Search movies & TV by genre/year/rating/votes, pull title details, cast & crew, episode lists, user reviews and ratings. Export IMDb datasets to JSON, CSV or Excel. For film analytics, ML and recommendations.
- **URL**: https://apify.com/logiover/imdb-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Videos, Business, Developer tools
- **Features:** Limited permissions
- **Stats:** 57 total users, 15 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
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
## IMDb Scraper β Movies, TV, Ratings, Reviews & Cast Data API (No API Key)
    
An **unofficial IMDb scraper** with structured output in a single Apify Actor. Search movies and TV shows, pull title details, ratings, user reviews, episode lists, and cast & crew through IMDb's web GraphQL endpoint. No API key, login, or headless browser is required. **Six modes share one input form**, and every result is tagged with `_mode` so you can filter mixed datasets later.
> ### π Why this IMDb scraper?
>
> **6 modes in 1 Actor** (advanced search, free-text search, title details, episodes, reviews, people) Β· powered by IMDb's web GraphQL Β· ratings + votes on titles and episodes Β· export to JSON / CSV / Excel β with **no API key** and **no browser**.
> **Usage restriction:** IMDb's GraphQL responses carry a licensing disclaimer that restricts public, commercial, and other non-private use. Use this Actor only where your use is permitted by IMDb's current terms and licensing rules; obtain an IMDb data license when required.
***
### β¨ What this Actor does / Key features
- π **Advanced title search** β filter tens of thousands of movies and TV shows by title type, genre, release-date range, IMDb rating and vote count; sort by popularity, rating, release date, runtime, box office or Metascore; paginates the full result set.
- β **Ratings everywhere** β `aggregateRating` and `voteCount` on every title and episode, straight from IMDb.
- π¬ **Rich title details** β `title`, `originalTitle`, `titleType`, `year`, `endYear`, `runtimeMinutes`, `genres[]`, `plot`, poster `imageUrl`, popularity rank and top `topCredits[]` (director, writers, cast).
- πΊ **Full episode lists** β every episode of a series with `seasonNumber`, `episodeNumber`, `releaseDate`, per-episode rating and plot.
- π¬ **User reviews** β reviewer, star rating, summary, full review text, submission date and helpfulness up/down votes.
- π€ **People (cast & crew)** β `name`, professions, biography, birth/death dates, photo and a `knownFor[]` filmography.
- 𧩠**Batch lookups** β feed many `ttβ¦` or `nmβ¦` IDs at once for `titleDetails` and `name` modes.
- ποΈ **5 pre-built dataset views** β Overview, Titles, Episodes, Reviews, People β slice the data with zero post-processing.
- β‘ **Direct GraphQL** β no browser, no API key, no OAuth; every item carries `_mode` and `scrapedAt` (ISO 8601).
#### The 6 modes
| Mode | What it returns |
|---|---|
| `searchTitles` | Advanced movie/TV search β filter by type, genre, year, rating, votes (highest volume) |
| `search` | Free-text search across titles, people and companies |
| `titleDetails` | Full details for one or many title IDs (batch) |
| `episodes` | Every episode of a TV series, paginated |
| `reviews` | User reviews for a title, paginated |
| `name` | Person / cast / crew details for one or many name IDs (batch) |
### π Quick start (3 steps)
1. **Pick a Mode** β start with `searchTitles` to build a filtered movie/TV dataset, or use `titleDetails` / `reviews` / `episodes` / `name` with an IMDb ID.
2. **Fill the fields that mode needs** β the input form shows which apply (search filters, or a `titleId` like `tt0111161` / `nameId` like `nm0000138`).
3. **Run & export** β download results as **JSON, CSV, Excel, HTML, RSS or JSON Lines**, or pull them via the Apify API.
### π₯ Input
Pick a `mode`, then fill only the fields that mode needs.
#### Example β advanced search for popular movies since 2020
```json
{
"mode": "searchTitles",
"titleTypes": ["movie"],
"releaseDateStart": "2020-01-01",
"minVotes": 5000,
"sortBy": "POPULARITY",
"maxResults": 200
}
```
#### Example β pull user reviews for a title
```json
{
"mode": "reviews",
"titleId": "tt0111161",
"maxResults": 500
}
```
#### Example β batch title details for several movies
```json
{
"mode": "titleDetails",
"titleIds": ["tt0111161", "tt0068646", "tt0468569"]
}
```
| Field | Type | Used by | Description |
|-------|------|---------|-------------|
| `mode` | string | all | `searchTitles`, `search`, `titleDetails`, `episodes`, `reviews` or `name`. **Required.** |
| `query` | string | search | Free-text term (movie, show, actor, director or company). |
| `searchType` | string | search | Restrict to `TITLE`, `NAME`, `COMPANY` or `KEYWORD`. |
| `titleTypes` | array | searchTitles | `movie`, `tvSeries`, `tvMiniSeries`, `tvMovie`, `short`, `videoGame`β¦ (defaults to `movie`). |
| `genres` | array | searchTitles | One or more genres (all must match): Action, Comedy, Drama, Sci-Fi⦠|
| `releaseDateStart` / `releaseDateEnd` | string | searchTitles | Release-date window (`YYYY-MM-DD`). |
| `minRating` / `maxRating` | number | searchTitles | IMDb average rating bounds (0β10), including decimals such as `7.5`. |
| `minVotes` | integer | searchTitles | Minimum vote count (filters out obscure entries). |
| `sortBy` | string | searchTitles | `POPULARITY`, `USER_RATING`, `USER_RATING_COUNT`, `RELEASE_DATE`, `RUNTIME`, `BOX_OFFICE_GROSS_DOMESTIC`, `METACRITIC_SCORE`. |
| `sortOrder` | string | searchTitles | `ASC` or `DESC`. |
| `titleId` / `titleIds` | string / array | titleDetails, episodes, reviews | IMDb title ID(s) like `tt0111161` (titleDetails accepts a batch). |
| `nameId` / `nameIds` | string / array | name | IMDb person ID(s) like `nm0000138` (batch supported). |
| `maxResults` | integer | all | Row cap; drives pagination for search/episodes/reviews. |
| `country` / `language` | string | all | Localization: `US` / `en-US`, `DE` / `de-DE`, `TR` / `tr-TR`β¦ |
### π€ Output
Results stream to the dataset; every item carries `_mode` and `scrapedAt`. Here is a trimmed **title** sample (from `searchTitles` / `titleDetails`):
```json
{
"_mode": "searchTitles",
"id": "tt0111161",
"title": "The Shawshank Redemption",
"titleType": "Movie",
"year": 1994,
"aggregateRating": 9.3,
"voteCount": 2894512,
"runtimeMinutes": 142,
"genres": ["Drama"],
"plot": "Over the course of several years, two convicts form a friendshipβ¦",
"imageUrl": "https://m.media-amazon.com/images/β¦/poster.jpg",
"imdbUrl": "https://www.imdb.com/title/tt0111161/",
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
And a trimmed **review** sample (from `reviews` mode):
```json
{
"_mode": "reviews",
"titleName": "The Shawshank Redemption",
"author": "alexdrama",
"authorRating": 10,
"summary": "A near-perfect film",
"text": "Few films earn their reputation the way this one doesβ¦",
"submissionDate": "2026-05-18",
"upVotes": 142,
"downVotes": 6,
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
π Full field reference by mode (click to expand)
**Titles** (`searchTitles`, `search`, `titleDetails`): `id`, `title`, `originalTitle`, `titleType`, `year`, `endYear`, `aggregateRating`, `voteCount`, `runtimeMinutes`, `genres[]`, `plot`, `imageUrl`, `topCredits[]`, `imdbUrl`
**Episodes** (`episodes`): `seriesTitle`, `seasonNumber`, `episodeNumber`, `title`, `releaseDate`, `aggregateRating`, `voteCount`, `plot`, `imdbUrl`
**Reviews** (`reviews`): `titleName`, `author`, `authorRating`, `summary`, `text`, `submissionDate`, `upVotes`, `downVotes`
**People** (`name`): `id`, `name`, `professions[]`, `birthDate`, `deathDate`, `bio`, `imageUrl`, `knownFor[]`, `imdbUrl`
**Universal** (every row): `_mode`, `imdbUrl`, `scrapedAt` (ISO 8601)
### π‘ Use cases
- **Film & TV analytics** β build a movie ratings dataset filtered by genre, decade and popularity, then chart trends in a BI tool.
- **Recommendation engines & ML (licensed use only)** β ingest titles, genres, ratings and cast when your IMDb license permits that processing.
- **Review mining & sentiment** β pull IMDb user reviews for a film or series and feed sentiment models or LLM summarizers.
- **Catalog enrichment** β enrich your own media catalog with IMDb metadata, posters, runtimes and cast lists via `titleDetails`.
- **Market & competitor research** β track top-rated or most-popular releases per year, monitor a studio's back catalog, or benchmark a show's episode ratings.
- **AI agents & RAG** β wrap the Actor as a tool so an LLM can answer "what are the top-rated sci-fi movies since 2020?" or embed plots and reviews.
### π₯ Who uses it
Film & TV data analysts Β· recommendation-engine and ML engineers Β· streaming & catalog teams enriching metadata Β· journalists and researchers Β· sentiment/NLP practitioners mining reviews Β· AI-agent builders wiring IMDb as a tool.
### π° Pricing
This Actor runs on a simple **pay-per-result** model. Actor pricing covers the extraction service only and does not grant an IMDb data license or expand your data-use rights. See the **Pricing** tab for the current Actor rate.
### β Frequently Asked Questions
**Do I need an IMDb API key or account?**
No IMDb credential is required for the web request, but this does not grant reuse rights. This unofficial Actor reads IMDb's web GraphQL endpoint; IMDb's response disclaimer and licensing rules still apply.
**Is this an IMDb API or an IMDb API alternative?**
It provides a structured automation interface, but it is not an official IMDb API or a substitute for required licensing. IMDb's response disclaimer and current terms still govern how the returned data may be used.
**How do I scrape IMDb ratings and vote counts?**
Every title and episode row includes `aggregateRating` (the IMDb average) and `voteCount`. Use `searchTitles` to build a filtered ratings dataset, or `titleDetails` for specific movies.
**How do I get IMDb IDs (tt and nm)?**
A title ID looks like `tt0111161` (the digits after `tt` in an IMDb title URL); a person ID looks like `nm0000138`. Use `search` or `searchTitles` first to discover IDs, then feed them into `titleDetails`, `episodes`, `reviews` or `name`.
**Can I scrape IMDb reviews without an API key?**
Yes. Pick `reviews` mode and set the `titleId`; the Actor paginates IMDb's web review feed. Use the returned data only where IMDb's current terms and your license permit it.
**Does it cover TV series and episodes?**
Yes. Use `searchTitles` with `titleTypes: ["tvSeries"]` to find shows, then `episodes` mode with the series `titleId` to pull every episode with season/episode numbers and per-episode ratings.
**How much data can advanced search return?**
Advanced title search runs against IMDb's full catalog β a single filter set can match hundreds of thousands of titles. The Actor paginates up to your `maxResults`, so you can pull large movie and TV datasets in one run.
**Is the data localized by country?**
You can set `country` and `language` (e.g. `US` / `en-US`, `DE` / `de-DE`) to influence IMDb localization of titles and text.
**How do I export IMDb data to CSV, JSON or Excel?**
Run any mode and download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSON Lines from the run page, or pull it via the Apify API. This makes it a simple IMDb data export and movie-dataset tool.
**Is it legal to scrape IMDb?**
The Actor reads data served by IMDb's web endpoint. IMDb's response disclaimer restricts public, commercial, and other non-private use; you are responsible for complying with IMDb's current terms, licensing requirements, and applicable laws.
### π More media & social scrapers by logiover
Building a media, entertainment or social dataset? Pair IMDb with the rest of the suite:
| Actor | What it does |
|---|---|
| [TVmaze Scraper](https://apify.com/logiover/tvmaze-scraper) | TV show schedules, episodes and cast from TVmaze |
| [MyAnimeList Scraper](https://apify.com/logiover/mal-anime-scraper) | Anime & manga titles, scores and metadata |
| [Letterboxd Film Review Scraper](https://apify.com/logiover/letterboxd-film-review-scraper) | Film reviews, ratings and lists from Letterboxd |
| [Steam Game Reviews Scraper](https://apify.com/logiover/steam-game-reviews-scraper) | Player reviews and ratings from Steam |
| [Discogs Scraper](https://apify.com/logiover/discogs-scraper) | Music releases, artists and labels from Discogs |
| [Apple Podcasts Episode Scraper](https://apify.com/logiover/apple-podcasts-episode-scraper) | Podcast episodes and show metadata |
| [YouTube Comments Scraper](https://apify.com/logiover/youtube-comments-scraper) | Comment threads and engagement from YouTube |
| [Twitch Scraper](https://apify.com/logiover/twitch-scraper) | Streams, channels and metadata from Twitch |
| [Reddit Subreddit Scraper](https://apify.com/logiover/reddit-search-scraper) | Posts, scores and comments from any subreddit |
| [Resident Advisor Scraper](https://apify.com/logiover/resident-advisor-scraper) | Music events, clubs and lineups |
| [Wikipedia Category Scraper](https://apify.com/logiover/wikipedia-category-scraper) | Walk Wikipedia categories and export page metadata |
π Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** β 180+ actors across real estate, jobs, crypto, social media & B2B data.
### β° Scheduling & integration
Schedule this Actor on Apify to refresh a movie/TV dataset daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI tools and webhooks through the Apify API. Call it from your stack via `run-sync-get-dataset-items`, the JavaScript/Python clients, or no-code tools like **Make, n8n and Zapier**.
### π€ AI Agents, MCP & RAG Integration
**IMDb Scraper** works natively as an on-demand data tool for AI assistants and autonomous workflows.
Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** β no custom wrapper code needed:
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com?tools=logiover/imdb-scraper"
}
}
}
```
- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.
### π¬ Support, Issues & Reviews
- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/imdb-scraper/issues) with your **Run ID** or sample input β we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/imdb-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/imdb-scraper/reviews) or bookmarking [logiover/imdb-scraper](https://apify.com/logiover/imdb-scraper) β organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.
### βοΈ Legal
This Actor reads data served by IMDb's web endpoint. It does not grant data-use rights: IMDb's response disclaimer restricts public, commercial, and other non-private use. You are responsible for obtaining any required license and complying with IMDb's terms and applicable law.
***
This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by IMDb; IMDb and all other trademarks mentioned here are the property of their respective owners.
### IMDb scraping β frequently asked questions
#### Do I need a IMDb API key, account or login?
No. This Actor reads publicly available pages and feeds, so there is nothing to register for and no credentials to manage.
#### How do I export IMDb data to CSV, Excel, JSON or Google Sheets?
Open the **Storage** tab after a run and pick the format you want β CSV, Excel, JSON, XML or an HTML table. For Google Sheets, Airtable or a database, use the dataset URL or the Apify API so the sheet refreshes itself on every run.
#### Can I schedule this IMDb scraper to run daily or hourly?
Yes. Use the **Schedules** tab and pick a cadence. Daily is enough for most tracking work; pick hourly only if the rows you care about really do change that fast.
#### How many rows can I get, and what does it cost?
See the volume section above for a measured figure. Billing is per result, so you pay for the rows you actually receive and a run that finds nothing costs nothing.
#### Is scraping IMDb legal?
This Actor collects only information that IMDb publishes publicly. It does not log in, does not defeat access controls and does not touch private data. You remain responsible for how you use the output, including under GDPR and similar rules where personal data is involved.
#### What happens if IMDb blocks the run or changes its layout?
A refused exit IP is swapped for a fresh one within a quarter of a second and retried, and rate limiting is waited out rather than fought. If nothing gets through, the run **fails with the reason** instead of reporting success with zero rows β so an empty result always means "no matches", never "the source would not answer".
#### Can I use this with an AI agent, LangChain or an MCP client?
Yes. The Actor is callable over the Apify API and through Apify's MCP server, so an agent can run it and read the dataset back as a tool call.
### π Changelog
#### 2026-11-11
- Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration.
- Added direct Issues & Reviews support links and refreshed live maintenance verification.
#### 2026-11-01
- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 1 link to renamed Actors updated, 1 link to retired Actors removed; independence disclaimer added.
#### 2026-10-15
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Runs with a short timeout (API and AI-agent calls) now finish inside it with what they collected, instead of being cut off.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example for `maxResults` is now 200 (was 120).
- The default used when the field is left out for `maxResults` is now 4,000 (was 200).
#### 2026-09-23
- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 15 columns returned, 93.3% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 1 column(s) came back empty in this sample (`endYear`); these are under review.
#### 2026-09-01
- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs β unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.
#### 2026-08-11
- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 15 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 19 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.
#### 2026-08-01 β Health-check remediation
- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Restored GraphQL access with the required IMDb referer, made zero-result transport/parser failures fail explicitly, added keyword mapping and corrected rating types and data-licensing guidance.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.
#### 2026-07-06
- β¨ README overhaul: added shields badges, a richer per-mode output sample and field reference, ready-to-run example scenarios, a media/social cross-promo grid, and a clearer quick-start.
#### 2026-07-01
- Initial release: six IMDb modes (advanced title search, free-text search, title details, episodes, reviews, people) over IMDb's web GraphQL endpoint β no key, no browser.
***
\*Maintained: last verified 2026-11-11 β checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).
# Changelog
This Actor's version history is a separate document: https://apify.com/logiover/imdb-scraper/changelog.md
# Actor input Schema
## `mode` (type: `string`):
Which IMDb endpoint to run.
β’ **searchTitles** β advanced movie/TV search: filter by type, genre, year, rating and votes; paginates through tens of thousands of matches (highest volume)
β’ **search** β free-text search across titles, people and companies
β’ **titleDetails** β full details for one or more title IDs (batch)
β’ **episodes** β every episode of a TV series (paginated)
β’ **reviews** β user reviews for a title (paginated)
β’ **name** β person / cast / crew details for one or more name IDs (batch)
## `query` (type: `string`):
Free-text term for **search** mode (movie name, show, actor, director or company).
## `searchType` (type: `string`):
Restrict **search** results to one entity type. Leave empty to search everything.
## `titleTypes` (type: `array`):
Filter **searchTitles** by one or more title types. Leave empty to default to Movies.
## `genres` (type: `array`):
Filter by one or more genres (all must match).
## `releaseDateStart` (type: `string`):
Only titles released on/after this date. Format `YYYY-MM-DD`.
## `releaseDateEnd` (type: `string`):
Only titles released on/before this date. Format `YYYY-MM-DD`.
## `minRating` (type: `number`):
Only titles with an average IMDb rating at or above this value.
## `maxRating` (type: `number`):
Only titles with an average IMDb rating at or below this value.
## `minVotes` (type: `integer`):
Only titles with at least this many user ratings. Great for filtering out obscure entries (e.g. 1000+).
## `sortBy` (type: `string`):
Ordering field for advanced title search.
## `sortOrder` (type: `string`):
ASC = most popular / lowest value first (for POPULARITY, ASC = most popular). DESC = highest value first.
## `titleId` (type: `string`):
IMDb title ID, e.g. `tt0111161`. Used by **titleDetails**, **episodes**, **reviews**. The digits after `tt` in an IMDb URL.
## `titleIds` (type: `array`):
Array of IMDb title IDs (`ttβ¦`) for batch **titleDetails**.
## `nameId` (type: `string`):
IMDb person ID, e.g. `nm0000138`. Used by **name** mode.
## `nameIds` (type: `array`):
Array of IMDb person IDs (`nmβ¦`) for batch **name** lookups.
## `maxResults` (type: `integer`):
Upper bound on rows returned. For searchTitles/episodes/reviews this drives pagination; for search it caps a single page (β€200).
## `country` (type: `string`):
ISO 3166-1 alpha-2 country code used for IMDb localization (affects regional titles, release dates and ranking).
## `language` (type: `string`):
BCP 47 language tag for IMDb localization (affects title language and text).
## Actor input object example
```json
{
"mode": "searchTitles",
"query": "christopher nolan",
"titleTypes": [
"movie"
],
"genres": [],
"releaseDateStart": "2020-01-01",
"releaseDateEnd": "2024-12-31",
"minVotes": 5000,
"sortBy": "POPULARITY",
"sortOrder": "ASC",
"titleId": "tt0944947",
"titleIds": [],
"nameId": "nm0000138",
"nameIds": [],
"maxResults": 200,
"country": "US",
"language": "en-US"
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset. Use the Titles view for search modes, Episodes for episode lists, Reviews for user reviews, and People for person lookups.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "searchTitles",
"titleTypes": [
"movie"
],
"releaseDateStart": "2020-01-01",
"minVotes": 5000,
"sortBy": "POPULARITY",
"maxResults": 200
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "searchTitles",
"titleTypes": ["movie"],
"releaseDateStart": "2020-01-01",
"minVotes": 5000,
"sortBy": "POPULARITY",
"maxResults": 200,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/imdb-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 '{
"mode": "searchTitles",
"titleTypes": [
"movie"
],
"releaseDateStart": "2020-01-01",
"minVotes": 5000,
"sortBy": "POPULARITY",
"maxResults": 200
}' |
apify call logiover/imdb-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/imdb-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 ` 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/bQqSK5gDIPEQqrq15/builds/pbk5550N2aAwDZIRm/openapi.json