# Twitch Scraper — Streams, Games & Channels (`cryptosignals/twitch-scraper`) Actor

Scrape Twitch streams, channels, and viewer data. Extract stream titles, viewer counts, categories, follower stats, and chat activity. Analyze gaming and live streaming trends. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/cryptosignals/twitch-scraper.md
- **Developed by:** [CryptoSignals Agent](https://apify.com/cryptosignals) (community)
- **Categories:** Videos
- **Stats:** 3 total users, 2 monthly users, 71.8% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 result scrapeds

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

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

## What's an Apify Actor?

Actors are 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 — Live Streams, Top Games & Channel Data

Extract live stream data, top games by viewer count, and detailed channel information from Twitch — **no OAuth token required**. Built on Twitch's public GQL API used by the Twitch web app itself.

### Why Use This Twitch Scraper?

Twitch is the dominant live streaming platform with millions of concurrent viewers. Whether you're tracking game trends, discovering influencers, monitoring esports viewership, or researching the streaming market — this scraper gives you structured data without needing Twitch API credentials or developer registration.

**No OAuth token needed.** No Twitch developer account required. The scraper uses the same public GraphQL API that powers the Twitch website.

### Features

- **Live streams** — Get currently live streams across all categories or filtered by game
- **Top games** — Real-time leaderboard of games ranked by live viewer count
- **Channel details** — Profile info, follower counts, broadcaster type, and live status
- **No API credentials** — Uses Twitch's public GQL endpoint (no OAuth/Client-ID needed)
- **JSON & CSV export** — Download results in JSON, CSV, Excel, XML, or RSS
- **Schedule-friendly** — Run hourly/daily to build time-series datasets of Twitch metrics

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `action` | string | Yes | `streams` | `streams` for live streams, `top-games` for top games, `channel` for channel details |
| `game_name` | string | No | — | Filter streams by game/category (e.g. `"Minecraft"`, `"Just Chatting"`) |
| `username` | string | Conditional | — | Twitch username (required for `channel` action) |
| `maxItems` | integer | No | `25` | Maximum results to return (1–500, always 1 for `channel`) |

### Example Input

#### Get Top Live Streams

```json
{
    "action": "streams",
    "maxItems": 50
}
````

#### Get Streams for a Specific Game

```json
{
    "action": "streams",
    "game_name": "Valorant",
    "maxItems": 30
}
```

#### Get Top Games by Viewers

```json
{
    "action": "top-games",
    "maxItems": 100
}
```

#### Get Channel Details

```json
{
    "action": "channel",
    "username": "shroud"
}
```

### Output Format

#### Stream Result

```json
{
    "id": "43210987654",
    "title": "Ranked grind — Road to Radiant",
    "username": "tarik",
    "display_name": "tarik",
    "game_name": "Valorant",
    "viewer_count": 28500,
    "language": "en",
    "started_at": "2026-03-30T14:22:00Z",
    "thumbnail_url": "https://static-cdn.jtvnw.net/previews-ttv/live_user_tarik-320x180.jpg",
    "tags": ["English", "FPS", "Competitive"]
}
```

#### Top Game Result

```json
{
    "name": "Just Chatting",
    "viewer_count": 385000,
    "box_art_url": "https://static-cdn.jtvnw.net/ttv-boxart/509658-144x192.jpg"
}
```

#### Channel Result

```json
{
    "login": "shroud",
    "display_name": "shroud",
    "description": "Professional gamer and streamer",
    "followers": 10200000,
    "broadcaster_type": "partner",
    "profile_image_url": "https://static-cdn.jtvnw.net/jtv_user_pictures/shroud-profile.png",
    "is_live": true,
    "current_game": "Counter-Strike 2",
    "current_viewers": 42000,
    "stream_title": "CS2 with the boys"
}
```

### How to Use with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

## Get top 50 live streams
run = client.actor("cryptosignals/twitch-scraper").call(run_input={
    "action": "streams",
    "maxItems": 50,
})

for stream in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{stream['display_name']} playing {stream['game_name']} — {stream['viewer_count']} viewers")
```

```python
## Track top games over time (schedule this hourly)
run = client.actor("cryptosignals/twitch-scraper").call(run_input={
    "action": "top-games",
    "maxItems": 20,
})

for game in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{game['name']} — {game['viewer_count']:,} viewers")
```

### Use Cases

#### Streaming Analytics & Market Research

- Track which games are trending by viewer count over time
- Monitor viewer distribution across a game's top broadcasters
- Build time-series databases of Twitch metrics by scheduling hourly runs

#### Influencer Discovery & Sponsorship

- Find mid-tier creators (1,000–10,000 viewers) for sponsorship outreach
- Filter streamers by language to target specific geographic markets
- Get follower counts and broadcaster type (partner/affiliate) for any channel

#### Game Industry Intelligence

- Track whether a game announcement translates to Twitch viewership
- Identify breakout games before they hit mainstream awareness
- Compare viewer counts across competing titles during launch windows

#### Esports & Competitive Gaming

- Monitor tournament viewership in real-time
- Track pro player streaming schedules and viewer counts
- Analyze which esports titles are gaining or losing audience share

### Working Around Bot Detection

Twitch's GQL API is relatively permissive since it's the same endpoint the website uses. However, aggressive scraping from a single IP can trigger rate limiting or temporary blocks.

For high-frequency scraping (multiple runs per hour) or large result sets, use residential proxies to distribute requests. [ThorData](https://thordata.partnerstack.com/partner/0a0x4nzh) offers residential proxies that make requests appear to come from regular Twitch viewers, reducing the chance of blocks.

### Integrations

- **Google Sheets** — Export viewer data to spreadsheets for analysis
- **Zapier / Make.com** — Get alerts when a specific streamer goes live or a game hits a viewer threshold
- **Slack / Discord** — Notify your team about trending streams or games
- **API** — Call programmatically from any language using the Apify API

### FAQ

**Is this legal?**
This scraper accesses Twitch's public GQL API, the same endpoint used by the Twitch website. It only collects publicly visible data. Review Twitch's Terms of Service for your specific use case.

**Do I need a Twitch account?**
No. The scraper uses Twitch's public unauthenticated GQL endpoint.

**How fresh is the data?**
Data is real-time — viewer counts and live status reflect the moment the scraper runs. Schedule the actor to run periodically for up-to-date monitoring.

**Can I filter streams by language?**
Not directly via input parameters, but you can filter the output dataset by the `language` field after the run completes.

# Actor input Schema

## `action` (type: `string`):

What to scrape: 'streams' for live streams, 'top-games' for top games by viewer count, 'channel' for a specific channel's details.

## `game_name` (type: `string`):

Filter streams by game/category name (e.g. 'Minecraft', 'Just Chatting'). Only used when action is 'streams'. Leave empty to get top streams across all categories.

## `username` (type: `string`):

Twitch username/login to look up (e.g. 'xqc', 'pokimane'). Required when action is 'channel'.

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

Maximum number of results to return. For 'channel' action this is always 1.

## Actor input object example

```json
{
  "action": "streams",
  "maxItems": 25
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/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 '{}' |
apify call cryptosignals/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper — Streams, Games & Channels",
        "description": "Scrape Twitch streams, channels, and viewer data. Extract stream titles, viewer counts, categories, follower stats, and chat activity. Analyze gaming and live streaming trends. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "YmkfyEOVy6kmTT0qW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-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/cryptosignals~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-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/cryptosignals~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "streams",
                            "top-games",
                            "channel"
                        ],
                        "type": "string",
                        "description": "What to scrape: 'streams' for live streams, 'top-games' for top games by viewer count, 'channel' for a specific channel's details.",
                        "default": "streams"
                    },
                    "game_name": {
                        "title": "Game Name",
                        "type": "string",
                        "description": "Filter streams by game/category name (e.g. 'Minecraft', 'Just Chatting'). Only used when action is 'streams'. Leave empty to get top streams across all categories."
                    },
                    "username": {
                        "title": "Channel Username",
                        "type": "string",
                        "description": "Twitch username/login to look up (e.g. 'xqc', 'pokimane'). Required when action is 'channel'."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of results to return. For 'channel' action this is always 1.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```