# Streaming Availability Scraper: Where to Watch by Country (`scrapemint/streaming-availability-scraper`) Actor

Check where any movie or show streams in 140+ countries: Netflix, Prime, Disney+ and every other service, with rent and buy prices and deep links. One row per title per country. For where-to-watch tools, VPN and affiliate content, catalog tracking. Keyless.

- **URL**: https://apify.com/scrapemint/streaming-availability-scraper.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Videos, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Streaming Availability Scraper: Where to Watch by Country

Streaming catalogs are different in every country. A title on Netflix US may be on Prime in Germany, on a local service in India, and not watchable at all in Brazil. This actor answers "where can people watch this title" for any list of movies and shows across 140+ countries, in one run. No login, no API key, no subscription.

Commercial streaming availability APIs charge $10 to $150 a month. Here you pay per row and the first rows of every run are free.

### What you get

One row per title per country:

| Field | Description |
|---|---|
| `searchQuery` | The title you asked for |
| `title`, `type`, `releaseYear` | Matched title, `movie` or `show`, release year |
| `imdbId`, `tmdbId` | External ids for joining with your own data |
| `genres` | Genre codes |
| `country` | ISO country code this row answers for |
| `available` | `true` if at least one offer exists in this country |
| `streamingServices` | Subscription services carrying it (Netflix, Prime Video, Disney+ etc.) |
| `rentServices`, `buyServices`, `freeServices` | Services by offer type |
| `offerCount`, `offers` | Full offer list: service, type (stream/rent/buy/free), price and currency where shown, available qualities (SD/HD/4K), direct deep link |
| `justwatchUrl`, `posterUrl` | Title page and poster image |

A row with zero offers is a real answer: the title is not watchable in that country right now.

### Input

- **Titles**: any list of movie or show names. The best match is used (raise "Matches per title" for ambiguous names like remakes).
- **Countries**: ISO codes, e.g. `US, GB, DE, IN, BR, JP, NG, KE`. 140+ supported.
- **Max rows per run**: cost cap.

3 titles x 5 countries = 15 rows. 50 titles x 20 countries = 1,000 rows.

### Pricing

Pay per result: **$0.005 per title x country row**. First 2 rows of every run are free.

Checking one title across 20 countries costs $0.09. A 100-title catalog across 5 countries costs $2.49. No subscription, no minimum.

### Typical uses

- **Where-to-watch sites and apps**: build or refresh availability pages with deep links per country.
- **VPN and affiliate content**: "what is on Netflix in X but not in Y" articles are an entire content niche; this gives you the matrix in one run.
- **Catalog tracking**: schedule a daily run over your watchlist and diff rows to catch titles entering or leaving services.
- **Distribution and rights research**: check which territories already have a title licensed and on which services.
- **Price comparison**: rent and buy prices per country in local currency.

### Scheduling

Run it on a schedule via Apify and consume rows through the API, webhooks, or the Google Sheets integration. Pair rows with your own IMDB or TMDB ids using the returned external ids.

### Data notes

Availability data reflects JustWatch's public catalog at run time. Offer prices are shown where the catalog publishes them (rentals and purchases); subscription offers carry no price. Coverage and freshness vary slightly by country.

# Actor input Schema

## `titles` (type: `array`):

Movie or show names to look up, e.g. Breaking Bad, Inception. Each is searched on JustWatch and the best match is used.
## `countries` (type: `array`):

ISO 3166-1 alpha-2 country codes to check, e.g. US, GB, DE, IN, BR, JP. One output row per title per country.
## `resultsPerTitle` (type: `integer`):

How many search matches to include per title (1 = best match only). Raise it when a name is ambiguous, e.g. remakes.
## `maxRows` (type: `integer`):

Cap on title x country rows returned. Controls total cost.

## Actor input object example

```json
{
  "titles": [
    "Breaking Bad",
    "Inception",
    "Oppenheimer"
  ],
  "countries": [
    "US",
    "GB",
    "DE",
    "IN",
    "BR"
  ],
  "resultsPerTitle": 1,
  "maxRows": 100
}
````

# 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 = {
    "titles": [
        "Breaking Bad",
        "Inception",
        "Oppenheimer"
    ],
    "countries": [
        "US",
        "GB",
        "DE",
        "IN",
        "BR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/streaming-availability-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 = {
    "titles": [
        "Breaking Bad",
        "Inception",
        "Oppenheimer",
    ],
    "countries": [
        "US",
        "GB",
        "DE",
        "IN",
        "BR",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/streaming-availability-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 '{
  "titles": [
    "Breaking Bad",
    "Inception",
    "Oppenheimer"
  ],
  "countries": [
    "US",
    "GB",
    "DE",
    "IN",
    "BR"
  ]
}' |
apify call scrapemint/streaming-availability-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Streaming Availability Scraper: Where to Watch by Country",
        "description": "Check where any movie or show streams in 140+ countries: Netflix, Prime, Disney+ and every other service, with rent and buy prices and deep links. One row per title per country. For where-to-watch tools, VPN and affiliate content, catalog tracking. Keyless.",
        "version": "0.1",
        "x-build-id": "HxK9b0LchS6bFLTbN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~streaming-availability-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-streaming-availability-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/scrapemint~streaming-availability-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-streaming-availability-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/scrapemint~streaming-availability-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-streaming-availability-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": {
                    "titles": {
                        "title": "Titles",
                        "type": "array",
                        "description": "Movie or show names to look up, e.g. Breaking Bad, Inception. Each is searched on JustWatch and the best match is used.",
                        "default": [
                            "Breaking Bad"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 country codes to check, e.g. US, GB, DE, IN, BR, JP. One output row per title per country.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerTitle": {
                        "title": "Matches per title",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many search matches to include per title (1 = best match only). Raise it when a name is ambiguous, e.g. remakes.",
                        "default": 1
                    },
                    "maxRows": {
                        "title": "Max rows per run",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap on title x country rows returned. Controls total cost.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
