# Netflix Scraper (`parseforge/netflix-scraper`) Actor

Scrape Netflix titles into flat rows with synopsis, cast, creators, genres, ratings, artwork and trailers, joined to Netflix's own weekly Top 10 view counts.

- **URL**: https://apify.com/parseforge/netflix-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 netflix title scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🍿 Netflix Scraper

> 🚀 **Export Netflix catalogue data in seconds.** 38 fields per title, and every row carries Netflix's own published viewing figures: Outer Banks came back at rank 1 with 9,400,000 weekly views and 80,600,000 hours viewed, not an estimate.

Netflix publishes two things separately and never joins them for you. Its title pages carry the metadata (synopsis, cast, creators, directors, genres, maturity rating, artwork, trailers), and `top10.netflix.com` publishes the actual weekly viewing figures. This Actor reads both and returns them as one flat row per title. No login, no API key, no cookie.

Every run returns **38 fields per title**. You can point it at title URLs, at bare numeric Netflix IDs, or at any of the **635 public Netflix genre collections**, each of which lists between 326 and 349 titles. The chart join reaches back to July 2021 and covers the **3,424 titles that have ever entered a global weekly Top 10**, with optional per-country coverage across 94 countries. Five titles take about 15 seconds end to end.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Streaming and media analysts | Track what Netflix is actually pushing, with real view counts rather than trade-press estimates. |
| Content acquisition and licensing teams | Measure how titles in a genre perform before bidding on comparable content. |
| Data journalists and researchers | Build reproducible datasets on streaming performance from first-party numbers. |
| Recommendation and ML engineers | Train on catalogue metadata joined to genuine engagement signals. |

### 📋 What the Netflix Scraper does

> 💡 **Why it matters:** Most Netflix scrapers hand you a synopsis and a cast list. That tells you what a title *is*, never how it *did*. Netflix itself publishes weekly views and hours viewed, but in a separate TSV keyed on a plain title string, so almost nobody joins the two. This Actor does that join on every row.

- 📊 **Netflix's own view counts, joined in.** Latest chart rank, weekly views, weekly hours viewed, best rank ever, and total weeks in the Top 10, straight from Netflix's published engagement data.
- 🏆 **All-time placement.** For the 32 titles on Netflix's all-time most-popular list, the rank and the views in the first 91 days.
- 🎬 **Full title metadata.** Synopsis, primary and secondary genres, cast, creators, directors, content rating, numeric maturity level, season count, and Netflix Original and ads-plan flags.
- 🖼 **Three distinct artworks.** The box-art image, the wide billboard, and the hero image, each a different asset rather than the same URL repeated.
- ▶️ **Trailer assets.** Trailer title, direct MP4 URL, ISO 8601 duration, and upload date.
- 🎞 **635 genre collections.** Every public Netflix genre, verified against Netflix's own sitemap, as a searchable dropdown. No guessed IDs.
- 🌍 **Optional per-country chart coverage.** The full list of countries where a title has ever charted, across 94 countries.
- 📦 **One fixed schema.** Every title lands with the same 38 columns and sentinels instead of nulls, so CSV and Excel imports stay predictable.

### 🎬 Full Demo (🚧 Coming soon)

A short walkthrough video is in production and will land here.

### 📊 Output

Each Netflix title becomes one flat row. These are the main fields:

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | Box-art image for the title. |
| 🎬 `title` | string | Title name as Netflix shows it. |
| 🎞 `type` | string | `Movie` or `Show`. |
| 🔗 `url` | string | Canonical Netflix title URL. |
| 🆔 `titleId` | string | Numeric Netflix title ID. |
| 📝 `synopsis` | string | Netflix's own synopsis. |
| 🏷 `primaryGenre` | string | First genre Netflix assigns. |
| 🔞 `contentRating` | string | Certification such as `TV-MA` or `PG-13`. |
| 📊 `maturityLevel` | integer | Netflix's numeric maturity value, for example `110`. |
| 📅 `dateCreated` | string | Netflix's schema.org `dateCreated`. For films this is the release date. |
| 🗓 `startDate` | string | Netflix's schema.org `startDate`. Series only. |
| 📚 `seasonCount` | integer | Number of seasons. Series only. |
| 🅽 `isNetflixOriginal` | string | `Yes` or `No`. |
| ✅ `isAvailable` | string | Whether the title is streamable in the catalogue reached. |
| 📺 `isPlayableOnAdsPlan` | string | `Yes` or `No`. |
| 🌍 `catalogCountry` | string | Which country's catalogue the row reflects. |
| 📈 `top10Category` | string | `Films (English)`, `TV (Non-English)` and so on. |
| 🔟 `top10LatestRank` | integer | Most recent weekly chart position. |
| 🗓 `top10LatestWeek` | string | Week that rank belongs to. |
| 👁 `top10WeeklyViews` | integer | Views Netflix reported for that week. |
| ⏱ `top10WeeklyHoursViewed` | integer | Hours viewed Netflix reported for that week. |
| 🏅 `top10BestRank` | integer | Best global rank the title has ever reached. |
| 📆 `top10WeeksInTop10` | integer | Total weeks it has spent in a global Top 10. |
| 🏆 `allTimeRank` | integer | Rank on Netflix's all-time most-popular list. |
| 🚀 `allTimeViewsFirst91Days` | integer | Views in the first 91 days, for all-time list titles. |
| 🎥 `trailerTitle` | string | Name of the trailer or clip. |
| ▶️ `trailerUrl` | string | Direct MP4 URL. |
| ⏳ `trailerDuration` | string | ISO 8601 duration, for example `PT1M47S`. |
| 📤 `trailerUploadDate` | string | When the trailer was published. |
| 🌄 `heroImageUrl` | string | Hero artwork. |
| 🖼 `billboardImageUrl` | string | Wide billboard artwork. |
| 🏷 `genres` | array | All genres Netflix assigns. |
| 🎭 `cast` | array | Billed cast. |
| ✍️ `creators` | array | Series creators. |
| 🎬 `directors` | array | Film directors. |
| 🌍 `top10Countries` | array | Countries where the title has ever charted. Opt-in. |
| 🕒 `scrapedAt` | string | ISO timestamp of collection. |
| ❌ `error` | string | Populated only on failed rows. |

Three real records from a run:

```json
{
  "title": "Outer Banks",
  "type": "Show",
  "titleId": "80236318",
  "primaryGenre": "Adventure",
  "contentRating": "TV-MA",
  "seasonCount": 5,
  "isNetflixOriginal": "Yes",
  "top10LatestRank": 1,
  "top10LatestWeek": "2026-08-23",
  "top10WeeklyViews": 9400000,
  "top10WeeklyHoursViewed": 80600000,
  "top10BestRank": 1,
  "top10WeeksInTop10": 33,
  "cast": ["Chase Stokes", "Madelyn Cline", "Madison Bailey"],
  "genres": ["Adventure", "Dramas"]
}
```

```json
{
  "title": "My Life With the Walter Boys",
  "type": "Show",
  "titleId": "81426967",
  "primaryGenre": "Romance",
  "contentRating": "TV-14",
  "seasonCount": 3,
  "isNetflixOriginal": "Yes",
  "top10LatestRank": 3,
  "top10LatestWeek": "2026-08-23",
  "top10WeeklyViews": 4300000,
  "top10WeeklyHoursViewed": 33900000,
  "top10BestRank": 1,
  "top10WeeksInTop10": 18,
  "cast": ["Nikki Rodriguez", "Sarah Rafferty", "Marc Blucas"],
  "genres": ["Romance", "Dramas"]
}
```

```json
{
  "title": "Death of the Pastor's Wife",
  "type": "Show",
  "titleId": "81989322",
  "primaryGenre": "Documentaries",
  "contentRating": "TV-MA",
  "seasonCount": 1,
  "isNetflixOriginal": "Yes",
  "top10LatestRank": "Not Disclosed",
  "top10WeeklyViews": "Not Disclosed",
  "top10WeeksInTop10": "Not Disclosed",
  "cast": [],
  "genres": ["Documentaries"]
}
```

That third row is the honest case. The title has never entered a global Top 10, so the chart columns carry `Not Disclosed` rather than a zero that would read as "nobody watched it".

### ✨ Why choose this Actor

- **Real viewing figures, not estimates.** Netflix's own weekly views and hours viewed, joined onto the catalogue metadata.
- **Verified genre list.** All 635 genre IDs come from Netflix's published sitemap, not from a blog post. Nothing in the dropdown 404s.
- **Complete rows.** Netflix renders its schema.org block only about half the time on any given request. This Actor re-requests until it lands, which is why `contentRating`, `seasonCount` and the trailer fields are populated instead of blank.
- **Honest about its limits.** The section below tells you exactly what this Actor cannot reach, before you spend anything.
- **Fast and light.** Plain HTTP, no browser, 512 MB, about 15 seconds for 5 titles.
- **No credentials.** No Netflix account, no cookie, no session token.

### 📈 How it compares to alternatives

| | This Actor | Typical Netflix scrapers |
|---|---|---|
| Netflix's own weekly view counts | **Yes**, joined onto every row | No |
| Weeks in Top 10 and best-ever rank | **Yes** | No |
| All-time views in first 91 days | **Yes**, for the 32 listed titles | No |
| Genre discovery | 635 verified genre collections | Keyword search, or a short hand-picked list |
| Fields per title | 38 | Commonly 10 to 20 |
| Three separate artwork assets | **Yes** | Usually one |
| Search by free-text keyword | **No.** See the ceiling below | Yes, several competitors do this |
| Login required | No | No |

**The ceilings, stated plainly.**

1. **No keyword search.** Netflix serves `/search` only to signed-in members, so there is no logged-out search surface to read. Discovery here runs through the 635 genre collections and through title URLs or IDs you supply. If you need free-text search, a competitor that logs in is the right tool and this one is not.
2. **326 to 349 titles per genre.** A Netflix genre page renders one fixed slice and offers no pagination. `?page=2` and friends return the same rows, so that slice is the per-genre maximum.
3. **The catalogue is the exit IP's country.** Netflix serves regional catalogues, and a locale prefix in the URL does nothing. On the default Apify proxy you get the **US catalogue**, and `catalogCountry` on every row says so. Point `proxyConfiguration` at another country to reach a different catalogue, which needs residential proxy access on your account.
4. **Chart matching is by title name.** The join uses Netflix's published chart names against Netflix's own page titles, which matched 64.1% of the titles on a sample genre page. A title whose chart name differs from its page name will show `Not Disclosed` rather than a wrong number.
5. **No view counts at country level.** Netflix publishes `weekly_views` only for the global charts. The per-country data gives coverage, not numbers.

### 🚀 How to use

1. **Create a free Apify account.** New accounts get $5 in free credit. [Sign up here](https://console.apify.com/sign-up?fpr=vmoqkp).
2. **Open the Actor** and go to the Input tab.
3. **Choose your titles.** Paste Netflix title URLs, drop in bare numeric title IDs, or pick from the genre dropdown. You can combine all three.
4. **Set Max Items** to the number of titles you want back.
5. **Leave chart enrichment on** to get the view counts, and optionally switch on per-country coverage.
6. **Filter by type** if you want films only or series only.
7. **Click Start** and watch the log.
8. **Download your data** from the Storage tab as CSV, JSON, Excel or XML, or pull it from the API.

### 💼 Business use cases

**📊 Genre performance benchmarking.**

A content strategy team pulls every title in the Thrillers and Documentaries collections, then ranks them by `top10WeeklyViews` and `top10WeeksInTop10`. Because the numbers are Netflix's own, the ranking survives scrutiny in a board deck in a way that trade-press estimates do not.

**🤝 Licensing comparables.**

An acquisitions analyst evaluating a thriller package pulls comparable titles by genre, filters to `isNetflixOriginal: "No"` to isolate licensed content, and checks how licensed thrillers actually performed before putting a number on the deal.

**📰 Data journalism.**

A reporter covering streaming builds a reproducible dataset joining catalogue metadata to first-party viewing figures, including `top10BestRank` and `top10WeeksInTop10`, so the story cites Netflix's own published numbers rather than an analyst's model.

**🤖 Recommender training data.**

An ML team assembles a training set of catalogue metadata (genres, cast, creators, maturity level, synopsis) paired with genuine engagement labels from the chart columns, instead of proxying popularity from third-party ratings.

### 🔌 Automating Netflix Scraper

- **Make:** run the Actor every Wednesday after Netflix publishes the new weekly charts, then update your tracking sheet.
- **Zapier:** connect the Actor to thousands of apps and start a run from any trigger.
- **Slack:** post the week's chart movers into a team channel so the content team sees them without opening a dashboard.
- **Airbyte:** sync the dataset into your warehouse to build a long-run view of catalogue performance.
- **GitHub:** schedule runs from an Actions workflow and commit the results alongside your analysis code.
- **Google Drive:** drop each run's CSV into a shared folder for the wider team.

### 🌟 Beyond business use cases

- **Research:** media scholars studying what actually travels on the largest streaming service, using first-party figures.
- **Personal:** film and TV enthusiasts building a watchlist from a genre collection, sorted by how well titles genuinely performed.
- **Non-profit:** cultural organisations tracking how documentary and non-English content is distributed and watched.
- **Experimentation:** developers prototyping popularity models against real engagement labels rather than scraped star ratings.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude or any assistant to plan your run:

> I am using the ParseForge Netflix Scraper on Apify. It takes Netflix title URLs, bare numeric title IDs, or a pick from 635 Netflix genre collections, and returns 38 fields per title: synopsis, cast, creators, directors, genres, content rating, maturity level, season count, three artwork URLs, trailer assets, and Netflix's own published Top 10 figures (latest rank, weekly views, weekly hours viewed, best rank, weeks in Top 10, and all-time views in the first 91 days). It cannot do free-text search, each genre page tops out at about 349 titles, and the catalogue returned is the one for the proxy's country, which defaults to the US. Help me design an input for \[describe your goal].

### ❓ Frequently Asked Questions

**🔑 Do I need a Netflix account?**
No. Everything this Actor reads is served to logged-out visitors.

**🔍 Can I search Netflix by keyword?**
No. Netflix serves `/search` only to signed-in members, so there is no logged-out search endpoint to read. Use the genre collections or supply title URLs and IDs.

**🌍 Which country's Netflix am I getting?**
Whichever country your proxy exits from, which is the US by default. Every row carries `catalogCountry` so you always know. A locale prefix in the URL has no effect, so the proxy is the only real lever.

**📊 Where do the view counts come from?**
Netflix publishes them itself at `top10.netflix.com`, updated weekly. This Actor downloads that data and joins it onto each title by name.

**🤔 Why do some rows say "Not Disclosed" in the chart columns?**
Because that title has never entered a global weekly Top 10, or its chart name differs from its page name. A sentinel is used rather than a zero, which would falsely read as "no views".

**📅 How far back does the chart data go?**
To the week of 4 July 2021, covering the 3,424 titles that have ever charted globally.

**🎬 How many titles can I get from one genre?**
Between 326 and 349. Netflix renders a genre page as one fixed slice with no pagination, so that is the maximum, and this Actor reports the true count it found.

**🔟 What is the difference between `top10BestRank` and `top10LatestRank`?**
`top10LatestRank` is the most recent week the title charted. `top10BestRank` is the best position it ever reached, which is usually the more useful number for comparing titles.

**⚡ How fast is it and how much memory does it need?**
Plain HTTP with no browser, 512 MB, about 15 seconds for 5 titles including downloading the chart data.

**🧱 Do I need a proxy?**
Yes, and it is on by default. Netflix rate-limits a single IP after roughly 400 requests, and once it does, that IP stops responding for several minutes.

**📉 Why are `contentRating` or the trailer fields sometimes empty?**
Netflix omits its schema.org block from a large share of responses. This Actor re-requests until it appears, so this is now rare. A handful of titles genuinely carry no trailer or release date in Netflix's own markup.

**📦 What export formats are supported?**
CSV, JSON, Excel and XML from the Storage tab, or straight from the Apify API.

### 🔌 Integrate with any app

Connect this Actor to Make, Zapier, Airbyte, n8n, Slack, Google Drive, GitHub Actions, or your own code through the Apify API and official clients for JavaScript and Python.

### 🔗 Recommended Actors

- [YouTube Comments Scraper](https://apify.com/parseforge/youtube-comments-scraper) for audience reaction to trailers and shows.
- [TikTok Hashtag Analytics Scraper](https://apify.com/parseforge/tiktok-hashtag-analytics-scraper) to measure how a title travels on social.
- [Reddit Scraper](https://apify.com/parseforge/reddit-posts-scraper) for discussion volume around a release.
- [X.com Profiles Scraper](https://apify.com/parseforge/x-com-profiles-scraper) to track cast and show accounts.
- [Twitch Live Streams Scraper](https://apify.com/parseforge/twitch-live-streams-scraper) for adjacent streaming-attention data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Netflix; only publicly available data.

# Actor input Schema

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

Netflix title pages (https://www.netflix.com/title/81040344) and/or genre pages (https://www.netflix.com/browse/genre/83). Genre pages are expanded into every title they list.

## `titleIds` (type: `array`):

Numeric Netflix title IDs, if you already have them. The ID is the last part of a Netflix title URL.

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

Pick from all 635 public Netflix genre collections. Each genre page lists 326-349 titles - Netflix does not paginate them, so that is the per-genre maximum.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Keep only films, only series, or both.

## `includeTop10` (type: `boolean`):

Joins each title to Netflix's own published engagement data: latest chart rank, weekly views, weekly hours viewed, best rank, weeks in the Top 10 and all-time views in the first 91 days. Adds about a second to the run.

## `includeCountryCharts` (type: `boolean`):

Adds the list of countries where a title has ever appeared in a weekly Top 10 (94 countries). Downloads a 32 MB dataset, so it makes the run noticeably slower. Netflix publishes no view counts at country level.

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

Netflix rate-limits a single IP after roughly 400 requests, so a proxy is on by default. Netflix also serves the catalog of the exit IP's country - set a country here to target a different regional catalog (needs residential proxy access on your account).

## `maxConcurrency` (type: `integer`):

Parallel requests to Netflix. Raise it for speed, lower it if you start seeing timeouts.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.netflix.com/title/81040344"
    }
  ],
  "maxItems": 10,
  "titleType": "any",
  "includeTop10": true,
  "includeCountryCharts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 4
}
```

# Actor output Schema

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

Key fields

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

Complete dataset with all 38 fields

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.netflix.com/title/81040344"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/netflix-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.netflix.com/title/81040344" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/netflix-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 '{
  "startUrls": [
    {
      "url": "https://www.netflix.com/title/81040344"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/netflix-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/netflix-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0Ksc9qd9Ti2Di1kl6/builds/xq5xqi0IsMi3mZ44v/openapi.json