# JustWatch Scraper - Streaming Availability, Offers & Prices (`scrapesage/justwatch-streaming-scraper`) Actor

Scrape JustWatch for where to watch any movie or TV show: streaming, rent & buy offers across Netflix, Prime, Disney+, Max, Hulu, Apple TV & 300+ services — prices, HD/4K quality, deep links, IMDb/TMDB scores, cast & leaving-soon dates. Discover, search or look up titles. Price-drop monitoring.

- **URL**: https://apify.com/scrapesage/justwatch-streaming-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Videos, E-commerce, Automation
- **Stats:** 3 total users, 1 monthly users, 94.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 streaming title results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## JustWatch Scraper — Streaming Availability, Offers & Prices (Movies & TV)

Find out **where to watch any movie or TV show** and **what it costs** — straight from [JustWatch](https://www.justwatch.com). For every title this actor returns the full list of **streaming, rent and buy offers** across **Netflix, Prime Video, Disney+, Max, Hulu, Apple TV, Paramount+, Peacock and 300+ services** in **140+ countries**, with **prices, video quality (HD/4K), deep links, previous prices, and "leaving soon" dates** — plus rich metadata: **IMDb & TMDB ids and scores, JustWatch rating, runtime, genres, age rating, poster, cast & crew, and seasons**.

No login, no cookies, no browser, no API key — fast, reliable extraction over JustWatch's public GraphQL API. **Discover** the catalogue by provider/genre/country, **search** by title, or look up **specific titles** by URL or id. Turn on **monitoring** to capture only **new releases, price drops and titles leaving a service**.

### Why this JustWatch scraper?

Generic "paste-a-URL" crawlers grab a few visible fields and miss what actually matters: the **offers**. This actor reads JustWatch's offer graph directly and ships the **richest dataset in the category** — every provider, every monetisation type, every price and quality tier, flattened into easy columns *and* kept as a full `offers` array.

| Data | Generic crawlers | This actor |
|---|---|---|
| Title, year, type, runtime, age rating | partial | ✅ |
| Genres, poster, descriptions | partial | ✅ |
| **IMDb id + score + votes**, **TMDB id + score**, JustWatch rating | ❌ | ✅ |
| **Every streaming/rent/buy offer** (provider, type, price, currency) | ❌ | ✅ |
| **Video quality** per offer (SD / HD / 4K / Blu-ray) | ❌ | ✅ |
| Deep link to watch/rent/buy | partial | ✅ |
| **Previous price** + price-drop flag | ❌ | ✅ |
| **"Leaving soon"** date + days remaining | ❌ | ✅ |
| Flattened summary: where to stream, cheapest rent/buy, best quality | ❌ | ✅ |
| Cast (with characters), directors, seasons | ❌ | ✅ (optional) |
| **Per-country** availability (140+ countries) | ❌ | ✅ |
| New-release / price-drop **monitoring** | ❌ | ✅ |

### Use cases

- **Streaming guide & affiliate sites** — power "where to watch" pages and earn on rent/buy/sub deep links, kept fresh automatically.
- **Price intelligence & comparison** — track rental and purchase prices across providers and currencies; catch price drops the day they happen.
- **Catalogue & competitive analysis** — see exactly what's on Netflix vs Disney+ vs Max in any country, by genre, year or rating.
- **"Leaving soon" alerts** — surface titles about to leave a subscription service so your users (or your app) never miss them.
- **Content & market research** — build datasets of availability, popularity and ratings for studios, distributors, analysts and journalists.
- **Recommendation & app data** — feed apps, bots and newsletters structured, LLM-ready availability data.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **JustWatch Scraper** and pick a **mode**: *Discover* (filter the catalogue), *Search* (by title name), or *Specific titles* (by URL/id).
3. Choose your **countries** (offers differ per country) and any filters — provider, genre, content type, year, offer type.
4. Click **Start** and watch results stream into the dataset table.
5. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "discover",
    "countries": ["US", "GB"],
    "contentTypes": ["MOVIE"],
    "providers": ["Netflix", "Max"],
    "genres": ["Science-Fiction"],
    "monetizationTypes": ["FLATRATE"],
    "sortBy": "TRENDING",
    "includeCredits": true,
    "maxResults": 100
}
```

- **mode** *(default `discover`)* — `discover` (filter/browse the catalogue), `search` (by title name), or `titles` (exact titles by URL/id). The mode auto-switches if you fill in search terms or title URLs.
- **searchQueries** — movie/show names for *Search* mode (e.g. `Oppenheimer`, `Dune`).
- **titleUrls** — JustWatch URLs for *Specific titles* mode (e.g. `https://www.justwatch.com/us/movie/oppenheimer`). Availability is resolved for every country you list.
- **titleIds** — JustWatch node ids: movies `tm…` (e.g. `tm1111989`), shows `ts…` (e.g. `ts70`).
- **countries** *(default `["US"]`)* — ISO country codes; one record is produced per title per country.
- **language** *(default `en`)* — 2-letter language code for titles & descriptions.
- **contentTypes** — `MOVIE` and/or `SHOW` (Discover/Search).
- **providers** — only titles on these services; use names (`Netflix`, `Disney Plus`, `Max`) or JustWatch short codes (`nfx`, `dnp`, `mxx`). Resolved per country.
- **genres** — names (`Comedy`, `Horror`, `Science-Fiction`) or codes (`cmy`, `hrr`, `scf`).
- **monetizationTypes** — `FLATRATE` (subscription), `RENT`, `BUY`, `FREE`, `ADS`.
- **releaseYearMin / releaseYearMax** — year range.
- **minImdbScore** — keep only titles at/above this IMDb score.
- **sortBy** *(default `POPULAR`)* — `POPULAR`, `TRENDING`, `IMDB_SCORE`, `TMDB_POPULARITY`, `ALPHABETICAL`, `RANDOM`.
- **includeCredits / includeSeasons / includeRawFields** *(default false)* — extra detail per title.
- **maxResults / maxResultsPerQuery** — caps for the run and per query/country.
- **monitorMode / monitorKey** — emit only new & changed titles across runs (see below).
- **maxConcurrency** *(default 4)* and **proxyConfiguration** — performance & proxy settings.

### Output

One clean record **per title, per country**. Beyond the flat columns below, every record keeps a full `offers` array and an availability summary.

```json
{
    "recordType": "title",
    "id": "tm1111989",
    "objectId": 1111989,
    "contentType": "movie",
    "country": "US",
    "title": "Oppenheimer",
    "releaseYear": 2023,
    "runtimeMinutes": 180,
    "ageCertification": "R",
    "genres": ["Drama", "History"],
    "posterUrl": "https://images.justwatch.com/poster/305252655/s592/oppenheimer.jpg",
    "justWatchUrl": "https://www.justwatch.com/us/movie/oppenheimer",
    "imdbId": "tt15398776",
    "imdbScore": 8.2,
    "imdbVotes": 1013416,
    "tmdbId": 872585,
    "tmdbScore": 8.026,
    "justWatchRating": 0.9239,
    "cast": [{ "name": "Cillian Murphy", "character": "J. Robert Oppenheimer" }],
    "directors": ["Christopher Nolan"],
    "offerCount": 27,
    "streamingOn": [],
    "canRent": true,
    "canBuy": true,
    "cheapestRentPrice": 3.99,
    "cheapestRentProvider": "Amazon Video",
    "cheapestBuyPrice": 7.5,
    "bestQuality": "4K Blu-ray",
    "has4K": true,
    "anyPriceDropped": false,
    "leavingSoon": [],
    "offers": [
        {
            "provider": "Amazon Video",
            "type": "RENT",
            "typeLabel": "Rent",
            "quality": "HD",
            "price": 3.99,
            "priceFormatted": "$3.99",
            "previousPrice": 3.79,
            "priceDropped": false,
            "currency": "USD",
            "url": "https://watch.amazon.com/detail?gti=...",
            "leavingDate": null
        }
    ],
    "scrapedAt": "2026-06-21T12:00:00.000Z"
}
```

Use the dataset **views** to switch focus instantly: **Where to watch**, **Offers & prices**, and **Catalog & ratings**.

#### What to expect (field coverage)

JustWatch aggregates studio/provider data, so a handful of fields appear only when the source has them. Verified across many titles, you can typically expect:

| Field group | Coverage |
|---|---|
| Title, type, year, JustWatch URL, poster | ~100% |
| Offers (when the title is available in that country) | ✅ full list with provider, type, price, quality, deep link |
| IMDb id & score, TMDB id & score | ~90%+ for mainstream titles |
| Runtime, genres, age rating, description | usually present |
| `previousPrice` / price-drop flag | present when JustWatch recorded a recent price change |
| `leavingSoon` / leaving date | present when a provider published an expiry |
| Cast & crew, seasons | present with `includeCredits` / `includeSeasons` |

A blank field means the source didn't publish it for that title in that country — not that scraping failed. Nothing is dropped, so you always get the richest dataset available.

### Monitoring — only new & changed titles

Turn on **monitorMode** and the actor remembers each title's offers in a named key-value store. On the next run it emits **only** titles that are **new** or whose **availability or price changed** — perfect for:

- **New-release alerts** — a title just appeared on Netflix/Prime/etc.
- **Price-drop tracking** — a rental or purchase price went down.
- **"Leaving soon" watches** — a title is about to leave a service.

Give each saved watch its own `monitorKey` so monitors don't share state. This works **alongside** [Apify Schedules](https://docs.apify.com/platform/schedules) — the schedule starts the run; monitoring decides what's worth emitting.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily to catch new releases, price drops and leaving-soon titles.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (Slack alert, Sheet append, email) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/justwatch-streaming-scraper').call({
    mode: 'discover',
    countries: ['US'],
    providers: ['Netflix'],
    contentTypes: ['MOVIE'],
    sortBy: 'TRENDING',
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} titles`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new releases or price drops into Slack, Sheets or your app.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored title changes availability.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find where to watch Oppenheimer in the US and the cheapest rental price" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **entertainment & media data stack**:

- **[IMDb Scraper](https://apify.com/scrapesage/imdb-scraper)** — movies & TV titles, ratings, cast and reviews.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — videos, channels, stats and comments.
- **[Spotify Scraper](https://apify.com/scrapesage/spotify-scraper)** — tracks, albums, artists and playlists.
- **[Apple Podcasts Scraper](https://apify.com/scrapesage/apple-podcasts-scraper)** — shows, episodes and rankings.
- **[Twitch Scraper](https://apify.com/scrapesage/twitch-scraper)** — streams, channels and category data.
- **[Steam Scraper](https://apify.com/scrapesage/steam-scraper)** — games, prices, reviews and tags.
- **[Goodreads Scraper](https://apify.com/scrapesage/goodreads-scraper)** — books, authors, ratings and reviews.
- **[Google Play Scraper](https://apify.com/scrapesage/google-play-scraper)** — apps, prices, ratings and reviews.

### Tips

- **Pick the right mode**: *Discover* for catalogue/competitive pulls, *Search* to resolve titles by name, *Specific titles* when you already have URLs/ids.
- **Compare countries** by listing several in `countries` — availability and prices differ a lot by region.
- **Provider names just work**: type `Netflix` or `Disney Plus` — the actor resolves them to JustWatch codes per country. Add several to widen the net.
- **Price-drop watch**: run in `monitorMode` on a daily [Schedule](https://docs.apify.com/platform/schedules) with a `RENT`/`BUY` filter to track price movements automatically.
- **Lean responses**: leave `includeCredits`/`includeSeasons` off for big catalogue pulls; turn them on when you need full detail.

### FAQ

**Does it need a JustWatch API key or login?** No. It reads JustWatch's public GraphQL data — no key, no cookies, no browser.

**How do I get availability for several countries?** List them in `countries`. Each title produces one record per country, since offers and prices are region-specific.

**Can I filter to one streaming service?** Yes — put it in `providers` (e.g. `Netflix`, `Max`) and the actor returns only titles available there.

**Where do prices come from?** From JustWatch's rent/buy/subscription offers per provider and country, including the formatted price, currency and the previous price when a recent change was recorded.

**Can I track price drops or new releases?** Yes — enable `monitorMode`. The actor emits only titles that are new or whose offers/prices changed since the last run.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**A field is empty — why?** Some titles lack an IMDb/TMDB id, a description, or offers in a given country. Fields are blank only when the source didn't publish that data — never because the scraper skipped it.

**Is scraping JustWatch legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws and JustWatch's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `mode` (type: `string`):

<b>Discover / browse</b> = filter the JustWatch catalogue by provider, genre, country, year & content type (the default). <b>Search</b> = look up titles by name. <b>Specific titles</b> = fetch exact movies/shows by JustWatch URL or id. The mode auto-switches if you fill in search terms or title URLs.

## `searchQueries` (type: `array`):

Movie or show names to search for, e.g. <code>Oppenheimer</code>, <code>Breaking Bad</code>, <code>Dune</code>. Used by <b>Search</b> mode.

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

Direct JustWatch title URLs for <b>Specific titles</b> mode, e.g. <code>https://www.justwatch.com/us/movie/oppenheimer</code> or <code>https://www.justwatch.com/us/tv-show/breaking-bad</code>. Availability is resolved for every country you list below.

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

JustWatch node ids for <b>Specific titles</b> mode: movies start with <code>tm</code> (e.g. <code>tm1111989</code>), shows with <code>ts</code> (e.g. <code>ts70</code>).

## `countries` (type: `array`):

ISO 3166 country codes to get availability for (offers differ per country), e.g. <code>US</code>, <code>GB</code>, <code>CA</code>, <code>AU</code>, <code>DE</code>, <code>FR</code>, <code>ES</code>, <code>IN</code>, <code>BR</code>. JustWatch covers 140+ countries. One record is produced per title per country.

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

2-letter language code for titles & descriptions, e.g. <code>en</code>, <code>de</code>, <code>fr</code>, <code>es</code>, <code>pt</code>.

## `contentTypes` (type: `array`):

Limit to movies and/or TV shows. Leave empty for both.

## `providers` (type: `array`):

Only titles available on these services. Use the provider name (e.g. <code>Netflix</code>, <code>Disney Plus</code>, <code>Amazon Prime Video</code>, <code>Max</code>, <code>Hulu</code>, <code>Apple TV Plus</code>, <code>Paramount Plus</code>, <code>Peacock</code>) or its JustWatch short code (<code>nfx</code>, <code>dnp</code>, <code>amp</code>, <code>mxx</code>, <code>hlu</code>). Names are resolved per country automatically.

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

Only titles in these genres. Use a name (<code>Comedy</code>, <code>Drama</code>, <code>Horror</code>, <code>Science-Fiction</code>, <code>Action & Adventure</code>) or JustWatch code (<code>cmy</code>, <code>drm</code>, <code>hrr</code>, <code>scf</code>, <code>act</code>).

## `monetizationTypes` (type: `array`):

Only titles offered with these monetisation types. <b>FLATRATE</b> = subscription/streaming, <b>RENT</b>, <b>BUY</b>, <b>FREE</b>, <b>ADS</b> = free with ads.

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

Only titles released in or after this year (Discover / Search).

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

Only titles released in or before this year (Discover / Search).

## `minImdbScore` (type: `string`):

Keep only titles with an IMDb score at or above this value, e.g. <code>7.0</code>. Applied to results after fetching.

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

Order of the catalogue results.

## `includeCredits` (type: `boolean`):

Attach full cast (with character names) and directors to each title.

## `includeSeasons` (type: `boolean`):

Attach the list of seasons (number + title) for TV shows.

## `includeRawFields` (type: `boolean`):

Attach the raw JustWatch API objects (content, offers, charts) under <code>sourceFields</code> for power users.

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

Maximum number of title records to produce in this run (across all countries & queries).

## `maxResultsPerQuery` (type: `integer`):

Optional cap on how many titles to take from each search term or each discover/country combination before moving on. Leave empty to use Max results.

## `deduplicateResults` (type: `boolean`):

Skip titles already emitted in this run (recommended).

## `monitorMode` (type: `boolean`):

Remember each title's offers in a named key-value store across runs and emit ONLY titles that are NEW or whose streaming availability / prices CHANGED since last run — perfect for new-release alerts, price-drop tracking and 'leaving soon' watches. Works alongside Apify Schedules.

## `monitorKey` (type: `string`):

Names the memory used by monitoring mode. Use a distinct key per saved watch so different monitors don't share state.

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

Maximum parallel requests. JustWatch is lightly rate-limited per IP — 4–8 is a good range.

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

Proxy settings. The default Apify Proxy rotates IPs to spread JustWatch's per-IP rate limit and improve reliability.

## Actor input object example

```json
{
  "mode": "discover",
  "searchQueries": [
    "Oppenheimer",
    "Breaking Bad"
  ],
  "countries": [
    "US"
  ],
  "language": "en",
  "contentTypes": [],
  "monetizationTypes": [],
  "sortBy": "POPULAR",
  "includeCredits": false,
  "includeSeasons": false,
  "includeRawFields": false,
  "maxResults": 100,
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorKey": "default",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped JustWatch title records in the default dataset, each with metadata, offers/prices and an availability summary.

# 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 = {
    "searchQueries": [
        "Oppenheimer",
        "Breaking Bad"
    ],
    "countries": [
        "US"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/justwatch-streaming-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 = {
    "searchQueries": [
        "Oppenheimer",
        "Breaking Bad",
    ],
    "countries": ["US"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/justwatch-streaming-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 '{
  "searchQueries": [
    "Oppenheimer",
    "Breaking Bad"
  ],
  "countries": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/justwatch-streaming-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2CsR12ovx5Ln2cXKw/builds/tj0DQggCam7dw99IJ/openapi.json