# Twitch Scraper (`crawlerbros/twitch-scraper`) Actor

Scrape Twitch, search channels/categories/videos/clips, fetch top live streams, channel info, top games, VOD metadata, and clip details. No login or API key required.

- **URL**: https://apify.com/crawlerbros/twitch-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 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

## Twitch Scraper

Scrape Twitch — top live streams, channel info, recent VODs, top clips, and game (category) directories. Pure HTTP via Twitch's public GraphQL endpoint. **No login or API key required.**

### What this actor does

Twitch's public website is powered by a GraphQL API at `gql.twitch.tv`. This actor talks to that API directly using the public web `Client-ID`, the same identifier the Twitch web frontend uses for unauthenticated browsing. That means the actor can pull:

- The current top live streams across Twitch (filterable by language)
- The top games/categories on Twitch right now
- Live streams within a single category
- Channel profile + recent VODs + top clips for any channel
- Top clips for a specific category over a chosen time window
- Single VODs by video ID
- Single clips by slug
- Full search across channels, categories, and videos
- Anything you can identify by a Twitch URL (channel, video, clip, or category page)

All output records are flat JSON with snake-case-style camelCase keys, omit-empty (no `null`/`""`/`[]`/`{}` anywhere in the dataset).

### Modes

| Mode | What you get |
|---|---|
| **Top live streams** (`topStreams`) | The most-viewed live streams across Twitch right now, with broadcaster, game, viewer count, language, tags, and preview thumbnail. Optional language filter. |
| **Top games / categories** (`topGames`) | The top categories on Twitch right now — sorted by current viewer count — with box art, follower counts, and broadcaster counts. |
| **Search Twitch** (`search`) | Free-text search across channels (users), games (categories), and videos. Restrict by `searchType` to `channel`, `game`, or `video` only. |
| **Channel info + VODs + clips** (`byChannel`) | Channel profile (followers, partner status, current live state, last broadcast, banner / profile / offline images) plus recent VODs and top clips. |
| **Browse a category** (`byCategory`) | Live streams currently broadcasting in a given category — filterable by language. |
| **Top clips for a category** (`topClips`) | Top clips for a category over a configurable time window (last day / week / month / all time). |
| **Lookup VOD by ID** (`byVideo`) | Full metadata for a single VOD — title, length, views, owner, game, broadcast type, language. |
| **Lookup clip by slug** (`byClip`) | Full metadata for a single clip — broadcaster, curator, source video, view count, embed URL. |
| **Resolve a Twitch URL** (`byUrl`) | Paste any list of Twitch URLs and the actor resolves each one to the right query (channel / VOD / clip / category page). |

### Filters

All filters apply across modes wherever the field exists. Records that don't have the field pass through (filter is opt-in, not opt-out).

- **Broadcast language** — restrict live streams and search to `EN` / `ES` / `DE` / `FR` / `PT` / `RU` / `JA` / `KO` / `ZH` / `IT` / `TR` / `PL` / `AR` / `TH` / `ID` / `VI` / `NL` / `SV` / `FI` / `DA` / `NO` / `CS` / `HU` / `EL` / `RO` / `BG` / `UK` / `HE` / `MS` / `TL` / `ASL` / `OTHER` (or `(any)` for no filter).
- **Min concurrent viewers** — drop live streams below this count.
- **Min total views** — drop VODs / clips below this view count.
- **Title contains keyword** — case-insensitive substring match against stream / video / clip titles.
- **VOD type** (`byChannel`) — `ARCHIVE`, `HIGHLIGHT`, `UPLOAD`, `PAST_PREMIERE`, `PREMIERE_UPLOAD`.
- **Video sort** (`byChannel`) — `TIME` (most recent first) or `VIEWS` (most-viewed first).
- **Clip time window** — `LAST_DAY`, `LAST_WEEK`, `LAST_MONTH`, or `ALL_TIME`.

### Output fields (per record)

Every record includes a `recordType` discriminator (`stream`, `channel`, `video`, `clip`, `game`, or `error`) and a `scrapedAt` ISO-8601 timestamp.

#### Live stream (`recordType: "stream"`)
`streamId`, `title`, `viewersCount`, `streamType`, `language`, `startedAt`, `previewImageURL`, `channelId`, `channelName`, `displayName`, `gameId`, `gameName`, `gameSlug`, `tags`, `broadcaster` (sub-object: `id`/`login`/`displayName`/`profileImageURL`/`primaryColorHex`), `game` (sub-object), `url`.

#### Channel (`recordType: "channel"`)
`channelId`, `channelName`, `displayName`, `description`, `createdAt`, `profileImageURL`, `bannerImageURL`, `offlineImageURL`, `primaryColorHex`, `isPartner`, `isAffiliate`, `isStaff`, `followersCount`, `streamTitle`, `currentGame` (sub-object), `liveStream` (sub-object — only present when live), `isLive`, `lastBroadcast` (sub-object), `url`.

#### VOD (`recordType: "video"`)
`videoId`, `title`, `description`, `lengthSeconds`, `viewCount`, `createdAt`, `publishedAt`, `previewImageURL`, `broadcastType`, `language`, `gameId`, `gameName`, `gameSlug`, `game` (sub-object), `channelId`, `channelName`, `displayName`, `owner` (sub-object), `url`.

#### Clip (`recordType: "clip"`)
`clipId`, `slug`, `title`, `viewCount`, `durationSeconds`, `createdAt`, `language`, `thumbnailURL`, `embedURL`, `videoOffsetSeconds`, `gameId`, `gameName`, `gameSlug`, `game` (sub-object), `channelId`, `channelName`, `displayName`, `broadcaster` (sub-object), `curator` (sub-object), `sourceVideo` (sub-object), `url`.

#### Game / category (`recordType: "game"`)
`gameId`, `name`, `displayName`, `slug`, `viewersCount`, `followersCount`, `broadcastersCount`, `boxArtURL`, `avatarURL`, `description`, `url`.

### Default daily-test prefill

The actor's saved prefill is `mode=topStreams, language=EN, maxItems=10`. This always returns ≥1 record because Twitch is always live somewhere — a strong daily-test default.

### FAQ

**Do I need a Twitch account or API key?**
No. The actor uses the public web `Client-ID` (the same one the Twitch site sends from incognito). Optional `authToken` input is supported for higher rate limits, but is never required.

**Why don't I see subscriber counts?**
Subscriber counts and a few other fields are gated by Twitch behind a logged-in OAuth token. Provide an `authToken` (the value of your `auth-token` cookie on twitch.tv) to unlock them, but they are not returned in default unauthenticated mode.

**Why does the actor sometimes engage Apify proxy automatically?**
Twitch's GraphQL endpoint occasionally rate-limits aggressive datacenter IPs. If the first attempt returns 0 records (e.g., 429 / 403), the actor lazily acquires an Apify proxy session and retries. Setting `useApifyProxy=true` up-front avoids the warmup hit.

**Can I scrape chat history?**
No. Chat (IRC / EventSub) is a separate live-streaming surface and out of scope for this actor.

**What's the difference between `byCategory` and `topClips`?**
`byCategory` returns *currently-live streams* in a category (use it to find people streaming a game right now). `topClips` returns *top clips* in that category over a chosen time window.

**How do I find a category slug?**
Open `https://www.twitch.tv/directory/category/<slug>` — for example `just-chatting`, `league-of-legends`, `valorant`. Or use the actor's `topGames` mode and read the `slug` field.

### Limitations

- Twitch's GraphQL endpoint may rotate persisted-query hashes; this actor side-steps that by sending **raw** GraphQL queries (no `persistedQuery` extension), so hash rotation can never break it. The schema itself is stable.
- Subscriber counts, paid emote slots, and other partner-only fields require an `authToken`.
- Per-clip exact rendering URLs (`.mp4` files) require a `gqlClipsAccessToken` separate flow that's beyond the scope of this actor; we surface the official embed URL instead.

### Pricing

Pricing is configured on the Apify platform. There is no charging logic in the actor code itself.

# Actor input Schema

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

What to fetch.
## `searchQuery` (type: `string`):

Free-text query for `mode=search` — matches channels, games, and videos.
## `searchType` (type: `string`):

Restrict search results to a single result type. `all` returns channels + games + videos.
## `channelName` (type: `string`):

Twitch channel login (the part after twitch.tv/, e.g. `lirik`, `shroud`, `pokimane`).
## `categorySlug` (type: `string`):

Twitch category (game) slug, e.g. `just-chatting`, `league-of-legends`, `valorant`. Find it from the URL: twitch.tv/directory/category/<slug>.
## `videoId` (type: `string`):

Twitch VOD ID, e.g. `2766365638`. Find it from twitch.tv/videos/<id>.
## `clipSlug` (type: `string`):

Twitch clip slug, e.g. `AcceptablePleasantAuberginePanicVis-EVdxDQ1vsQAQZpBS`. Find it from twitch.tv/<channel>/clip/<slug>.
## `twitchUrls` (type: `array`):

Direct Twitch URLs to resolve. Supports channel pages (twitch.tv/<channel>), VOD pages (twitch.tv/videos/<id>), clip pages (twitch.tv/<channel>/clip/<slug>), and category pages (twitch.tv/directory/category/<slug>).
## `language` (type: `string`):

Filter live streams (and search results) to a specific broadcast language. Applies to `topStreams`, `byCategory`, and `search`. Leave on `(any)` for no filter.
## `streamType` (type: `string`):

Restrict the VOD list returned for a channel to a specific broadcast type. Leave blank for all types.
## `videoSort` (type: `string`):

How to sort the channel's VODs.
## `clipPeriod` (type: `string`):

For `topClips` and `byChannel` clip lists: time window over which clips were created.
## `includeChannelClips` (type: `boolean`):

When `mode=byChannel`, also fetch and emit top clips for the channel.
## `includeChannelVideos` (type: `boolean`):

When `mode=byChannel`, also fetch and emit recent VODs for the channel.
## `minViewersCount` (type: `integer`):

Drop live streams with fewer concurrent viewers than this. Applies to `topStreams` and `byCategory`.
## `minViewCount` (type: `integer`):

Drop VODs and clips with fewer total views than this.
## `containsKeyword` (type: `string`):

Substring filter applied case-insensitively to stream/video/clip titles.
## `authToken` (type: `string`):

Optional Twitch OAuth user-token (the value of the `auth-token` cookie on twitch.tv when logged in). Increases rate limits and can unlock subscriber-only data. Not required for any mode.
## `useApifyProxy` (type: `boolean`):

Route requests through the Apify proxy from the start. When OFF the actor still auto-engages the proxy if the first direct attempt emits zero records, so leaving this OFF saves cost on most runs.
## `maxItems` (type: `integer`):

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "topStreams",
  "searchQuery": "lirik",
  "searchType": "all",
  "twitchUrls": [],
  "language": "EN",
  "streamType": "",
  "videoSort": "TIME",
  "clipPeriod": "LAST_WEEK",
  "includeChannelClips": true,
  "includeChannelVideos": true,
  "useApifyProxy": false,
  "maxItems": 10
}
````

# Actor output Schema

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

Dataset containing all scraped Twitch records (streams, channels, videos, clips, games).

# 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 = {
    "mode": "topStreams",
    "searchQuery": "lirik",
    "searchType": "all",
    "twitchUrls": [],
    "language": "EN",
    "streamType": "",
    "videoSort": "TIME",
    "clipPeriod": "LAST_WEEK",
    "includeChannelClips": true,
    "includeChannelVideos": true,
    "useApifyProxy": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/twitch-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 = {
    "mode": "topStreams",
    "searchQuery": "lirik",
    "searchType": "all",
    "twitchUrls": [],
    "language": "EN",
    "streamType": "",
    "videoSort": "TIME",
    "clipPeriod": "LAST_WEEK",
    "includeChannelClips": True,
    "includeChannelVideos": True,
    "useApifyProxy": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/twitch-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 '{
  "mode": "topStreams",
  "searchQuery": "lirik",
  "searchType": "all",
  "twitchUrls": [],
  "language": "EN",
  "streamType": "",
  "videoSort": "TIME",
  "clipPeriod": "LAST_WEEK",
  "includeChannelClips": true,
  "includeChannelVideos": true,
  "useApifyProxy": false,
  "maxItems": 10
}' |
apify call crawlerbros/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper",
        "description": "Scrape Twitch, search channels/categories/videos/clips, fetch top live streams, channel info, top games, VOD metadata, and clip details. No login or API key required.",
        "version": "1.0",
        "x-build-id": "YvVhirKj7bwvfjK09"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-twitch-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~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-twitch-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~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-twitch-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "topStreams",
                            "topGames",
                            "search",
                            "byChannel",
                            "byCategory",
                            "topClips",
                            "byVideo",
                            "byClip",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "topStreams"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query for `mode=search` — matches channels, games, and videos.",
                        "default": "lirik"
                    },
                    "searchType": {
                        "title": "Search result type (mode=search)",
                        "enum": [
                            "all",
                            "channel",
                            "game",
                            "video"
                        ],
                        "type": "string",
                        "description": "Restrict search results to a single result type. `all` returns channels + games + videos.",
                        "default": "all"
                    },
                    "channelName": {
                        "title": "Channel login / name (mode=byChannel)",
                        "type": "string",
                        "description": "Twitch channel login (the part after twitch.tv/, e.g. `lirik`, `shroud`, `pokimane`)."
                    },
                    "categorySlug": {
                        "title": "Category slug (mode=byCategory or topClips)",
                        "type": "string",
                        "description": "Twitch category (game) slug, e.g. `just-chatting`, `league-of-legends`, `valorant`. Find it from the URL: twitch.tv/directory/category/<slug>."
                    },
                    "videoId": {
                        "title": "Video ID (mode=byVideo)",
                        "type": "string",
                        "description": "Twitch VOD ID, e.g. `2766365638`. Find it from twitch.tv/videos/<id>."
                    },
                    "clipSlug": {
                        "title": "Clip slug (mode=byClip)",
                        "type": "string",
                        "description": "Twitch clip slug, e.g. `AcceptablePleasantAuberginePanicVis-EVdxDQ1vsQAQZpBS`. Find it from twitch.tv/<channel>/clip/<slug>."
                    },
                    "twitchUrls": {
                        "title": "Twitch URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct Twitch URLs to resolve. Supports channel pages (twitch.tv/<channel>), VOD pages (twitch.tv/videos/<id>), clip pages (twitch.tv/<channel>/clip/<slug>), and category pages (twitch.tv/directory/category/<slug>).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Broadcast language",
                        "enum": [
                            "",
                            "EN",
                            "ES",
                            "DE",
                            "FR",
                            "PT",
                            "RU",
                            "JA",
                            "KO",
                            "ZH",
                            "IT",
                            "TR",
                            "PL",
                            "AR",
                            "TH",
                            "ID",
                            "VI",
                            "NL",
                            "SV",
                            "FI",
                            "DA",
                            "NO",
                            "CS",
                            "HU",
                            "EL",
                            "RO",
                            "BG",
                            "UK",
                            "HE",
                            "MS",
                            "TL",
                            "ASL",
                            "OTHER"
                        ],
                        "type": "string",
                        "description": "Filter live streams (and search results) to a specific broadcast language. Applies to `topStreams`, `byCategory`, and `search`. Leave on `(any)` for no filter.",
                        "default": "EN"
                    },
                    "streamType": {
                        "title": "VOD type filter (mode=byChannel)",
                        "enum": [
                            "",
                            "ARCHIVE",
                            "HIGHLIGHT",
                            "UPLOAD",
                            "PAST_PREMIERE",
                            "PREMIERE_UPLOAD"
                        ],
                        "type": "string",
                        "description": "Restrict the VOD list returned for a channel to a specific broadcast type. Leave blank for all types.",
                        "default": ""
                    },
                    "videoSort": {
                        "title": "Video sort order (mode=byChannel)",
                        "enum": [
                            "TIME",
                            "VIEWS"
                        ],
                        "type": "string",
                        "description": "How to sort the channel's VODs.",
                        "default": "TIME"
                    },
                    "clipPeriod": {
                        "title": "Clip time window",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "For `topClips` and `byChannel` clip lists: time window over which clips were created.",
                        "default": "LAST_WEEK"
                    },
                    "includeChannelClips": {
                        "title": "Include clips (mode=byChannel)",
                        "type": "boolean",
                        "description": "When `mode=byChannel`, also fetch and emit top clips for the channel.",
                        "default": true
                    },
                    "includeChannelVideos": {
                        "title": "Include VODs (mode=byChannel)",
                        "type": "boolean",
                        "description": "When `mode=byChannel`, also fetch and emit recent VODs for the channel.",
                        "default": true
                    },
                    "minViewersCount": {
                        "title": "Min concurrent viewers (live streams filter)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop live streams with fewer concurrent viewers than this. Applies to `topStreams` and `byCategory`."
                    },
                    "minViewCount": {
                        "title": "Min total views (videos / clips filter)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop VODs and clips with fewer total views than this."
                    },
                    "containsKeyword": {
                        "title": "Title contains keyword",
                        "type": "string",
                        "description": "Substring filter applied case-insensitively to stream/video/clip titles."
                    },
                    "authToken": {
                        "title": "Twitch OAuth token (optional)",
                        "type": "string",
                        "description": "Optional Twitch OAuth user-token (the value of the `auth-token` cookie on twitch.tv when logged in). Increases rate limits and can unlock subscriber-only data. Not required for any mode."
                    },
                    "useApifyProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route requests through the Apify proxy from the start. When OFF the actor still auto-engages the proxy if the first direct attempt emits zero records, so leaving this OFF saves cost on most runs.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
