# JustWatch + Trakt Scraper (`crawlerbros/justwatch-trakt-scraper`) Actor

Combined movies/TV scraper covering JustWatch (60+ countries, streaming-availability + offers) and Trakt (movies/shows/episodes/people, popular/trending/anticipated). One actor, two surfaces, switchable via the `platform` input.

- **URL**: https://apify.com/crawlerbros/justwatch-trakt-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Videos
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## JustWatch + Trakt Scraper

Scrape movies, TV shows, episodes, and people from **JustWatch** (streaming
availability + offers across 60+ countries) and **Trakt** (popular,
trending, anticipated, public lists, calendar releases). One actor, two
sources — switch between them with a single `platform` input.

### Quick Start

1. Pick a `platform` — `justwatch` (no auth, default) or `trakt`.
2. Pick a `mode` — `popular` is the easiest no-input run.
3. (Trakt only) paste a free Client ID from
   [trakt.tv/oauth/applications](https://trakt.tv/oauth/applications) into
   `traktClientId`.
4. Run. The default daily test (`platform=justwatch, mode=popular,
   country=US, maxItems=10`) returns ~10 records with no auth and no proxy.

### What it does

#### JustWatch (no auth required)

JustWatch tracks where every movie / TV show is streaming in 60+ countries
— Netflix, Disney+, Hulu, Max, Prime Video, Apple TV+, regional services,
plus rent/buy offers from Apple TV, Google Play, Amazon Video, etc. This
actor exposes:

- **Search** — text query → matching titles with their availability.
- **By URL / path** — paste any `justwatch.com/<country>/<type>/<slug>` URL
  to get the full title record + offers.
- **By streaming provider** — list popular titles available on Netflix /
  Hulu / Max / Disney+ / Apple TV+ / 40+ providers, in any country.
- **Popular / Trending** — most-popular and currently-trending titles per
  country, optionally narrowed to movies-only or shows-only.

Each record includes: title, original title, original release year,
description, poster + backdrop URLs, genres, IMDb ID, runtime, age
certification, IMDb / TMDB / Rotten Tomatoes scores, top credits, and the
full offer list (which providers, monetization model — subscription / rent
/ buy / free / ads / cinema — and prices).

#### Trakt (requires free API key)

Trakt is the open community database for movies & TV. This actor uses the
official Trakt REST API (`api.trakt.tv`) to expose:

- **Search** — across movies, shows, episodes, people, lists.
- **By URL / slug / ID** — direct lookup of `trakt.tv/movies/...`,
  `trakt.tv/shows/...`, or any Trakt slug or numeric ID.
- **Popular / Trending / Anticipated** — for movies and shows.
- **By user** — public lists owned by a Trakt user, or items inside a
  specific public list.
- **Calendar releases** — upcoming movies / show episodes / season
  premieres / DVD releases for any date window (1–31 days).

Each record includes: title, year, IMDb / TMDB / TVDB IDs, slug, overview,
release / first-aired date, runtime, genres, certification, rating, votes,
network (shows), watcher count, and per-record metadata.

> **Trakt requires an API key** — get a free one at
> [trakt.tv/oauth/applications](https://trakt.tv/oauth/applications):
> create an app, copy the Client ID, paste it into `traktClientId`. Trakt
> rejects every request without a valid key.

### Inputs

| Field | Required | Description |
|---|---|---|
| `platform` | yes | `justwatch` or `trakt` |
| `mode` | yes | What to scrape (see modes below) |
| `searchQuery` | mode=search | Free-text query |
| `urls` | mode=byTitle | Title URLs / Trakt slugs / numeric IDs |
| `country` | optional | ISO 3166-1 alpha-2 (60+ supported, JustWatch availability is country-specific) |
| `language` | optional | ISO 639-1 (titles / descriptions returned in this language) |
| `titleType` | optional | `all`, `movie`, `show`, `episode`, `person`, `list` |
| `streamingProvider` | mode=byProvider (JustWatch) | Provider technical name (`netflix`, `hulu`, `max`, etc.) |
| `monetizationType` | optional (JustWatch) | `FLATRATE`, `RENT`, `BUY`, `FREE`, `ADS`, `CINEMA`, `FAST` |
| `objectType` | optional (JustWatch) | `MOVIE`, `SHOW`, or `all` |
| `minYear` / `maxYear` | optional | Release-year filter |
| `minImdbScore` | optional (JustWatch) | Drop titles with IMDb score below |
| `traktClientId` | yes (Trakt) | Free API key from trakt.tv |
| `traktSort` | optional (Trakt) | `popularity`, `trending`, `rating`, `votes`, etc. |
| `traktUsername` | mode=byUser | Trakt username for public lists |
| `traktListSlug` | optional (mode=byUser) | Specific list slug |
| `calendarStartDate` | optional (Trakt calendar) | YYYY-MM-DD; defaults to today |
| `calendarDays` | optional (Trakt calendar) | 1–31; defaults 7 |
| `calendarKind` | optional (Trakt calendar) | `movies`, `shows`, `new-shows`, `premieres`, `dvd` |
| `includeOffers` | optional (JustWatch) | Whether to enrich each title with full offer list |
| `maxItems` | optional | Hard cap on records, default 30 |
| `autoEscalateOnBlock` | optional | Auto-engage Apify proxy if datacenter IP gets blocked |
| `proxyGroups` | optional | Apify proxy groups to use on escalation |
| `rehostMediaUrls` | optional | Default `true`. Rehost JustWatch poster/backdrop/icon URLs into Apify storage so they download from any client. Disable for raw upstream URLs. |

### Modes

#### `platform=justwatch`

| Mode | What it does |
|---|---|
| `search` | Text query → matching titles |
| `byTitle` | Single title by JustWatch URL or `/{country}/{type}/{slug}` path |
| `byProvider` | Popular titles available on a specific streaming service |
| `popular` | Most popular titles in the chosen country |
| `trending` | Currently-trending titles |

#### `platform=trakt`

| Mode | What it does |
|---|---|
| `search` | Search across movies / shows / episodes / people / lists |
| `byTitle` | Single title by Trakt URL, slug, or numeric ID |
| `popular` | Most popular movies / shows |
| `trending` | Currently-trending movies / shows |
| `anticipated` | Most anticipated upcoming titles |
| `byUser` | Public lists owned by a Trakt user |
| `calendarReleases` | Upcoming releases for a date window |

### Sample outputs

#### JustWatch movie

```json
{
  "platform": "justwatch",
  "recordType": "movie",
  "id": "tm10",
  "objectType": "MOVIE",
  "country": "US",
  "language": "en",
  "url": "https://www.justwatch.com/us/movie/the-matrix",
  "title": "The Matrix",
  "year": 1999,
  "imdbId": "tt0133093",
  "runtimeMinutes": 138,
  "ageCertification": "R",
  "genres": ["Action & Adventure", "Science-Fiction"],
  "scoring": { "imdbScore": 8.7, "tomatoMeter": 83, "certifiedFresh": true },
  "offers": [
    {
      "monetizationType": "FLATRATE",
      "providerName": "Netflix",
      "providerSlug": "netflix",
      "url": "https://netflix.com/..."
    },
    { "monetizationType": "RENT", "providerName": "Apple TV", "retailPrice": "$3.99", "currency": "USD" }
  ],
  "scrapedAt": "2026-05-08T..."
}
````

#### Trakt show

```json
{
  "platform": "trakt",
  "recordType": "show",
  "title": "Breaking Bad",
  "year": 2008,
  "traktId": 1,
  "slug": "breaking-bad",
  "url": "https://trakt.tv/shows/breaking-bad",
  "imdbId": "tt0903747",
  "tmdbId": 1396,
  "overview": "An ordinary teacher...",
  "firstAired": "2008-01-20T...",
  "network": "AMC",
  "rating": 9.12,
  "votes": 100000,
  "airedEpisodes": 62,
  "genres": ["drama", "crime"],
  "scrapedAt": "2026-05-08T..."
}
```

### FAQ

**Do I need a JustWatch API key?**
No. JustWatch's GraphQL endpoint is public (Cloudflare-fronted; this actor
uses Chrome-131 TLS impersonation to satisfy the WAF).

**Do I need a Trakt API key?**
Yes — Trakt rejects every request without one. It's free; sign up at
[trakt.tv](https://trakt.tv) and create an app at
[trakt.tv/oauth/applications](https://trakt.tv/oauth/applications). Paste
the Client ID into `traktClientId`.

**Why is my JustWatch run different across countries?**
Streaming availability is country-specific. A title available on Netflix
US might be on Disney+ in the UK and unavailable in Japan.

**What languages are supported?**
JustWatch supports localised titles, descriptions, and genre translations
in 30+ languages. Trakt mostly returns English by default.

**Does the actor support pagination beyond `maxItems`?**
JustWatch returns up to 100 results per query; Trakt paginates 50 per
page. Internally the actor pages until `maxItems` or the upstream runs
out of results.

**Can I narrow by streaming provider in JustWatch search/popular?**
Yes — set `streamingProvider` to filter offers in any mode. For
provider-only browsing, use `mode=byProvider`.

**Will my run get blocked?**
JustWatch is fronted by Cloudflare — the Chrome-131 TLS impersonation
handles that without proxy on most runs. If it fails, set
`autoEscalateOnBlock: true` (default) to engage Apify proxy.

**Why are some JustWatch image URLs rehosted on Apify storage?**
JustWatch's image CDN (`images.justwatch.com`) only serves a small
allowlist of size profiles per asset path — every other size returns
HTTP 400 from a clean shell, even with a `Referer` header. This is
hotlink protection, similar to Pinterest's `i.pinimg.com`. To make sure
the URLs in your dataset download from any client (curl, Python
`requests`, your data pipeline, etc.), the actor downloads each image
once and rehosts it on Apify's Key-Value Store. The original JustWatch
URL is preserved on a parallel `posterUrlOriginal` /
`backdropUrlsOriginal` / `providerIconUrlOriginal` field for
traceability. Disable rehosting via `rehostMediaUrls: false` if you have
your own browser-side image proxy or want raw upstream URLs only.

### Output URL fields

| Field | Type | Notes |
|---|---|---|
| `posterUrl` | string | When `rehostMediaUrls=true` (default), this is an Apify Key-Value Store URL — permanent and downloadable from any client. When `false`, this is the upstream `images.justwatch.com` URL (may HTTP 400 outside a browser session). |
| `posterUrlOriginal` | string | Present only when rehosting. Holds the original `images.justwatch.com` URL for provenance / debugging. |
| `backdropUrls` | string\[] | Same rehosting rules as `posterUrl`. |
| `backdropUrlsOriginal` | string\[] | Parallel array with original upstream URLs. |
| `offers[].providerIconUrl` | string | Same rehosting rules. |
| `offers[].providerIconUrlOriginal` | string | Original icon URL for provenance. |

### Limitations

- **Trakt API key required**: the daily test prefill uses JustWatch
  (no auth) to ensure ≥1 record without user input. Trakt-mode users must
  supply `traktClientId`.
- **No personal Trakt data**: only public endpoints (popular / trending /
  anticipated / public lists / calendar). User-history / watchlist / profile
  data requires OAuth which this actor does not support.
- **No fuzzy ID lookup on Trakt byTitle without URL**: a bare slug is
  assumed to be a movie. To force a show, supply the full URL.
- **JustWatch episode-level offers**: this actor returns title-level
  offers (the offer list per movie/show). Per-episode offers are
  returned when a season-specific URL is given as `urls`.

# Actor input Schema

## `platform` (type: `string`):

Which source to scrape. JustWatch = streaming availability + offers. Trakt = popular/trending/anticipated movies & shows + per-user lists.

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

What to scrape. JustWatch supports: search, byTitle (URL/path), byProvider, popular, trending. Trakt supports: search, byTitle, popular, trending, anticipated, byUser (public lists), calendarReleases.

## `searchQuery` (type: `string`):

Free-text query. Required for mode=search.

## `urls` (type: `array`):

JustWatch full URLs (https://www.justwatch.com/us/movie/the-matrix) or Trakt URLs (https://trakt.tv/movies/the-matrix-1999) / Trakt slugs (e.g. `the-matrix-1999`) / Trakt numeric IDs.

## `country` (type: `string`):

Country code. JustWatch availability/offers are country-specific (60+ supported). Trakt mostly ignores country.

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

Language of returned titles/descriptions/genres. Falls back to country default if unsupported.

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

Restrict to movies, shows, episodes, people, or lists. Defaults to all.

## `streamingProvider` (type: `string`):

Streaming-service technical name. Use `mode=byProvider` to list titles available on this service in the chosen country. (JustWatch only.)

## `monetizationType` (type: `string`):

Restrict offers shown to a single monetization model.

## `objectType` (type: `string`):

Filter JustWatch results to movies only, shows only, or both.

## `minYear` (type: `integer`):

Drop titles with original release year before this.

## `maxYear` (type: `integer`):

Drop titles with original release year after this.

## `minImdbScore` (type: `integer`):

Drop titles whose IMDb score is below this. JustWatch results only.

## `traktClientId` (type: `string`):

REQUIRED when platform=trakt. Free key from https://trakt.tv/oauth/applications — create an app, copy the Client ID. Trakt rejects requests without a valid key.

## `traktSort` (type: `string`):

Sort order for Trakt search results. Trakt only.

## `traktUsername` (type: `string`):

Trakt username whose public lists & list items to scrape. Trakt only.

## `traktListSlug` (type: `string`):

Optional: specific public list slug under the user. If empty, returns all public lists' metadata. Trakt only.

## `calendarStartDate` (type: `string`):

ISO date (YYYY-MM-DD) for the start of the calendar window. Defaults to today.

## `calendarDays` (type: `integer`):

Number of days to include from the start date. 1–31.

## `calendarKind` (type: `string`):

Type of releases to include in the calendar.

## `includeOffers` (type: `boolean`):

Whether to enrich each JustWatch title with its full offer list (which providers, rent/buy/sub, prices). Adds 1 fetch per title — slower but richer. JustWatch only.

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

Hard cap on number of records to push.

## `autoEscalateOnBlock` (type: `boolean`):

If true, the actor automatically engages Apify Proxy when it hits HTTP 403/429 from a raw datacenter IP. Default true.

## `rehostMediaUrls` (type: `boolean`):

JustWatch's image CDN (images.justwatch.com) blocks direct downloads with HTTP 400 from outside a browser session — its anti-hotlink protection rejects size profiles outside its allowlist regardless of Referer. With this on (the default), the actor downloads each poster/backdrop/provider icon once and rehosts it on Apify's Key-Value Store, so the URLs you receive in your dataset are permanent, anonymous, and downloadable from any client. The original JustWatch URL is preserved on a parallel `<field>Original` field for traceability. Turn off if you have your own browser-side image proxy and want raw upstream URLs.

## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating. Empty = datacenter (default), then residential fallback.

## Actor input object example

```json
{
  "platform": "justwatch",
  "mode": "popular",
  "searchQuery": "the matrix",
  "urls": [
    "https://www.justwatch.com/us/movie/the-matrix"
  ],
  "country": "US",
  "language": "en",
  "titleType": "all",
  "monetizationType": "all",
  "objectType": "all",
  "traktSort": "popularity",
  "calendarDays": 7,
  "calendarKind": "movies",
  "includeOffers": true,
  "maxItems": 30,
  "autoEscalateOnBlock": true,
  "rehostMediaUrls": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of every scraped record (movies, shows, episodes, people, lists).

# 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 = {
    "platform": "justwatch",
    "mode": "popular",
    "country": "US",
    "language": "en",
    "titleType": "all",
    "monetizationType": "all",
    "objectType": "all",
    "traktSort": "popularity",
    "calendarDays": 7,
    "calendarKind": "movies",
    "includeOffers": true,
    "maxItems": 30,
    "autoEscalateOnBlock": true,
    "rehostMediaUrls": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/justwatch-trakt-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 = {
    "platform": "justwatch",
    "mode": "popular",
    "country": "US",
    "language": "en",
    "titleType": "all",
    "monetizationType": "all",
    "objectType": "all",
    "traktSort": "popularity",
    "calendarDays": 7,
    "calendarKind": "movies",
    "includeOffers": True,
    "maxItems": 30,
    "autoEscalateOnBlock": True,
    "rehostMediaUrls": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/justwatch-trakt-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 '{
  "platform": "justwatch",
  "mode": "popular",
  "country": "US",
  "language": "en",
  "titleType": "all",
  "monetizationType": "all",
  "objectType": "all",
  "traktSort": "popularity",
  "calendarDays": 7,
  "calendarKind": "movies",
  "includeOffers": true,
  "maxItems": 30,
  "autoEscalateOnBlock": true,
  "rehostMediaUrls": true
}' |
apify call crawlerbros/justwatch-trakt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JustWatch + Trakt Scraper",
        "description": "Combined movies/TV scraper covering JustWatch (60+ countries, streaming-availability + offers) and Trakt (movies/shows/episodes/people, popular/trending/anticipated). One actor, two surfaces, switchable via the `platform` input.",
        "version": "1.1",
        "x-build-id": "beVnmNjf8GxVoCbWx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~justwatch-trakt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-justwatch-trakt-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/crawlerbros~justwatch-trakt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-justwatch-trakt-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/crawlerbros~justwatch-trakt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-justwatch-trakt-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",
                "required": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "justwatch",
                            "trakt"
                        ],
                        "type": "string",
                        "description": "Which source to scrape. JustWatch = streaming availability + offers. Trakt = popular/trending/anticipated movies & shows + per-user lists.",
                        "default": "justwatch"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byTitle",
                            "byProvider",
                            "popular",
                            "trending",
                            "anticipated",
                            "byUser",
                            "calendarReleases"
                        ],
                        "type": "string",
                        "description": "What to scrape. JustWatch supports: search, byTitle (URL/path), byProvider, popular, trending. Trakt supports: search, byTitle, popular, trending, anticipated, byUser (public lists), calendarReleases.",
                        "default": "popular"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query. Required for mode=search."
                    },
                    "urls": {
                        "title": "Title URLs / IDs (mode=byTitle)",
                        "type": "array",
                        "description": "JustWatch full URLs (https://www.justwatch.com/us/movie/the-matrix) or Trakt URLs (https://trakt.tv/movies/the-matrix-1999) / Trakt slugs (e.g. `the-matrix-1999`) / Trakt numeric IDs.",
                        "default": [
                            "https://www.justwatch.com/us/movie/the-matrix"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country (ISO 3166-1 alpha-2)",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "ZA",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "PT",
                            "NL",
                            "BE",
                            "AT",
                            "CH",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "IS",
                            "PL",
                            "CZ",
                            "SK",
                            "HU",
                            "RO",
                            "BG",
                            "GR",
                            "TR",
                            "RU",
                            "UA",
                            "EE",
                            "LV",
                            "LT",
                            "HR",
                            "SI",
                            "RS",
                            "BR",
                            "MX",
                            "AR",
                            "CL",
                            "CO",
                            "PE",
                            "VE",
                            "EC",
                            "BO",
                            "PY",
                            "UY",
                            "JP",
                            "KR",
                            "CN",
                            "TW",
                            "HK",
                            "SG",
                            "MY",
                            "TH",
                            "ID",
                            "PH",
                            "VN",
                            "IN",
                            "PK",
                            "AE",
                            "SA",
                            "EG",
                            "IL",
                            "MA",
                            "DZ",
                            "TN",
                            "NG",
                            "GH",
                            "KE"
                        ],
                        "type": "string",
                        "description": "Country code. JustWatch availability/offers are country-specific (60+ supported). Trakt mostly ignores country.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language (ISO 639-1)",
                        "enum": [
                            "en",
                            "es",
                            "pt",
                            "fr",
                            "de",
                            "it",
                            "nl",
                            "pl",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "ja",
                            "ko",
                            "zh",
                            "ru",
                            "tr",
                            "el",
                            "cs",
                            "sk",
                            "hu",
                            "ro",
                            "bg",
                            "hr",
                            "sl",
                            "uk",
                            "ar",
                            "he",
                            "hi",
                            "th",
                            "id",
                            "ms",
                            "vi",
                            "tl"
                        ],
                        "type": "string",
                        "description": "Language of returned titles/descriptions/genres. Falls back to country default if unsupported.",
                        "default": "en"
                    },
                    "titleType": {
                        "title": "Title type filter",
                        "enum": [
                            "all",
                            "movie",
                            "show",
                            "episode",
                            "person",
                            "list"
                        ],
                        "type": "string",
                        "description": "Restrict to movies, shows, episodes, people, or lists. Defaults to all.",
                        "default": "all"
                    },
                    "streamingProvider": {
                        "title": "Streaming provider (mode=byProvider, JustWatch)",
                        "enum": [
                            "netflix",
                            "amazonprime",
                            "disneyplus",
                            "hulu",
                            "max",
                            "appletvplus",
                            "paramountplus",
                            "peacocktv",
                            "starz",
                            "showtime",
                            "discoveryplus",
                            "crunchyroll",
                            "fubotv",
                            "amc",
                            "britbox",
                            "acorntv",
                            "sundancenow",
                            "shudder",
                            "mubi",
                            "criterionchannel",
                            "kanopy",
                            "hoopla",
                            "tubi",
                            "pluto",
                            "freevee",
                            "youtube",
                            "play",
                            "itunes",
                            "amazon",
                            "vudu",
                            "now",
                            "skyshowtime",
                            "canalplus",
                            "rakutenviki",
                            "wakanim",
                            "globoplay",
                            "claroplay",
                            "starplus",
                            "lionsgateplus",
                            "nowtv",
                            "videoland",
                            "pathethuis",
                            "sky",
                            "filmin",
                            "movistarplus",
                            "rai",
                            "mediasetinfinity",
                            "telecomitalia"
                        ],
                        "type": "string",
                        "description": "Streaming-service technical name. Use `mode=byProvider` to list titles available on this service in the chosen country. (JustWatch only.)"
                    },
                    "monetizationType": {
                        "title": "Monetization type filter (JustWatch)",
                        "enum": [
                            "all",
                            "FLATRATE",
                            "FREE",
                            "ADS",
                            "RENT",
                            "BUY",
                            "CINEMA",
                            "FAST"
                        ],
                        "type": "string",
                        "description": "Restrict offers shown to a single monetization model.",
                        "default": "all"
                    },
                    "objectType": {
                        "title": "Object type filter (JustWatch popular/search)",
                        "enum": [
                            "all",
                            "MOVIE",
                            "SHOW"
                        ],
                        "type": "string",
                        "description": "Filter JustWatch results to movies only, shows only, or both.",
                        "default": "all"
                    },
                    "minYear": {
                        "title": "Min release year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop titles with original release year before this."
                    },
                    "maxYear": {
                        "title": "Max release year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop titles with original release year after this."
                    },
                    "minImdbScore": {
                        "title": "Min IMDb score (JustWatch)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop titles whose IMDb score is below this. JustWatch results only."
                    },
                    "traktClientId": {
                        "title": "Trakt API key (client_id)",
                        "type": "string",
                        "description": "REQUIRED when platform=trakt. Free key from https://trakt.tv/oauth/applications — create an app, copy the Client ID. Trakt rejects requests without a valid key."
                    },
                    "traktSort": {
                        "title": "Trakt sort (mode=search)",
                        "enum": [
                            "popularity",
                            "trending",
                            "rating",
                            "votes",
                            "recently_updated",
                            "released"
                        ],
                        "type": "string",
                        "description": "Sort order for Trakt search results. Trakt only.",
                        "default": "popularity"
                    },
                    "traktUsername": {
                        "title": "Trakt username (mode=byUser)",
                        "type": "string",
                        "description": "Trakt username whose public lists & list items to scrape. Trakt only."
                    },
                    "traktListSlug": {
                        "title": "Trakt list slug (mode=byUser)",
                        "type": "string",
                        "description": "Optional: specific public list slug under the user. If empty, returns all public lists' metadata. Trakt only."
                    },
                    "calendarStartDate": {
                        "title": "Calendar start date (mode=calendarReleases, Trakt)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD) for the start of the calendar window. Defaults to today."
                    },
                    "calendarDays": {
                        "title": "Calendar days (mode=calendarReleases, Trakt)",
                        "minimum": 1,
                        "maximum": 31,
                        "type": "integer",
                        "description": "Number of days to include from the start date. 1–31.",
                        "default": 7
                    },
                    "calendarKind": {
                        "title": "Calendar kind (mode=calendarReleases, Trakt)",
                        "enum": [
                            "movies",
                            "shows",
                            "new-shows",
                            "premieres",
                            "dvd"
                        ],
                        "type": "string",
                        "description": "Type of releases to include in the calendar.",
                        "default": "movies"
                    },
                    "includeOffers": {
                        "title": "Include streaming offers (JustWatch)",
                        "type": "boolean",
                        "description": "Whether to enrich each JustWatch title with its full offer list (which providers, rent/buy/sub, prices). Adds 1 fetch per title — slower but richer. JustWatch only.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on number of records to push.",
                        "default": 30
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true, the actor automatically engages Apify Proxy when it hits HTTP 403/429 from a raw datacenter IP. Default true.",
                        "default": true
                    },
                    "rehostMediaUrls": {
                        "title": "Rehost JustWatch images to Apify storage (recommended)",
                        "type": "boolean",
                        "description": "JustWatch's image CDN (images.justwatch.com) blocks direct downloads with HTTP 400 from outside a browser session — its anti-hotlink protection rejects size profiles outside its allowlist regardless of Referer. With this on (the default), the actor downloads each poster/backdrop/provider icon once and rehosts it on Apify's Key-Value Store, so the URLs you receive in your dataset are permanent, anonymous, and downloadable from any client. The original JustWatch URL is preserved on a parallel `<field>Original` field for traceability. Turn off if you have your own browser-side image proxy and want raw upstream URLs.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating. Empty = datacenter (default), then residential fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
