# Twitch Scraper - Channels, Followers & Live Viewers (`goat255/twitch-scraper`) Actor

Collect Twitch channel data by handle, by search, or by whoever is live in a category right now. Each row has follower count, partner status, live viewer count, current title, category and tags, plus optional recent videos and top clips.

- **URL**: https://apify.com/goat255/twitch-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Automation, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 channel scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Collect channel data by handle, by search, or by whoever is live in a category right now. Every row carries the follower count, the live viewer count, and what the channel is streaming. No login and no API key.

### What it does

- **Three ways to pick channels** - name them directly, search by topic, or pull whoever is live in a category. Mix all three in one run and the list is merged and de-duplicated for you.
- **Live state at run time** - a plain `isLive` flag, current viewer count, stream title, category and tags.
- **Audience size** - follower count, partner and affiliate status, and team.
- **Recent output** - optionally attach up to 100 recent videos and up to 100 top clips per channel, each with its own view count and duration.
- **Channel history** - account creation date and last broadcast, so you can tell an established channel from a new one.
- **Bulk friendly** - channels are fetched in batches, so a list of hundreds is one straightforward run.

Live viewer counts change minute to minute, so schedule the run to build a picture over time rather than a single snapshot.

Common uses: influencer and sponsorship research, category and game popularity tracking, audience benchmarking, esports and creator monitoring, and building a streaming dataset.

### Input

| Field | Type | Description |
|---|---|---|
| `channels` | array | Channel URLs or handles. Both forms work. |
| `searchTerms` | array | Find channels by name or topic. Up to 10 channels per term. |
| `categories` | array | Channels live in a category right now. |
| `maxChannelsPerCategory` | integer | Live channels to take per category. Default 30, up to 100. |
| `maxVideosPerChannel` | integer | Attach recent videos. 0 to skip, up to 100. |
| `maxClipsPerChannel` | integer | Attach top clips. 0 to skip, up to 100. |
| `liveChannelsOnly` | boolean | Keep only channels streaming at run time. |
| `proxyConfiguration` | object | Optional. Enable to spread requests across IPs. |

At least one of `channels`, `searchTerms` or `categories` is required.

#### Example input

```json
{
  "channels": ["example_user", "https://www.twitch.tv/example_streamer"],
  "categories": ["Just Chatting"],
  "maxChannelsPerCategory": 50,
  "maxClipsPerChannel": 20
}
````

### Output

Each item is one channel.

```json
{
  "id": "100000001",
  "login": "example_user",
  "displayName": "Example User",
  "url": "https://www.twitch.tv/example_user",
  "description": "A short channel bio.",
  "createdAt": "2016-04-11T10:22:31.000Z",
  "followerCount": 482913,
  "isPartner": true,
  "isAffiliate": false,
  "team": null,
  "isLive": true,
  "liveViewerCount": 3417,
  "liveTitle": "Ranked climb, day 12",
  "liveCategory": "Example Game",
  "liveStartedAt": "2026-07-18T18:16:20Z",
  "liveTags": ["English", "Ranked"],
  "streamTitle": "Ranked climb, day 12",
  "streamCategory": "Example Game",
  "language": "EN",
  "lastBroadcastAt": "2026-07-18T18:16:20Z",
  "lastBroadcastTitle": "Ranked climb, day 12",
  "profileImage": "https://example.com/avatar.png",
  "bannerImage": null,
  "discoveredVia": "input"
}
```

When a channel is offline the `live*` fields are empty and the rest of the row is unchanged, so the shape is always the same. `videos` and `clips` arrays are added only when you ask for them.

### Notes

- No login and no API key. Give it channels, search terms or categories and run.
- `discoveredVia` records whether a row came from your list, a search, or a category.
- Handles that no longer exist are reported in the run log and skipped, and are not charged.
- A category returns the channels with the most viewers first, so a smaller cap still gives you the top of that category.

### Privacy

To improve our actors we collect anonymized usage telemetry (run stats and input patterns). No personal account data is collected.

# Actor input Schema

## `channels` (type: `array`):

Channel URLs or handles. Both forms work. Leave empty if you are discovering channels instead.

## `searchTerms` (type: `array`):

Find channels by name or topic. Returns up to 10 channels per term.

## `categories` (type: `array`):

Collect channels that are live in a category right now, for example a game name.

## `maxChannelsPerCategory` (type: `integer`):

How many live channels to take from each category, ordered by viewers.

## `maxVideosPerChannel` (type: `integer`):

Attach recent videos to each channel. 0 to skip. Up to 100.

## `maxClipsPerChannel` (type: `integer`):

Attach top clips to each channel. 0 to skip. Up to 100.

## `liveChannelsOnly` (type: `boolean`):

Keep only channels that are streaming at the moment of the run.

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

Optional. Enable to spread requests across IPs on large runs.

## Actor input object example

```json
{
  "channels": [
    "example_user"
  ],
  "searchTerms": [
    "speedrun"
  ],
  "categories": [
    "Just Chatting"
  ],
  "maxChannelsPerCategory": 30,
  "maxVideosPerChannel": 0,
  "maxClipsPerChannel": 0,
  "liveChannelsOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `channels` (type: `string`):

No description

# 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 = {
    "channels": [
        "https://www.twitch.tv/twitch"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = {
    "channels": ["https://www.twitch.tv/twitch"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/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 '{
  "channels": [
    "https://www.twitch.tv/twitch"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call goat255/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper - Channels, Followers & Live Viewers",
        "description": "Collect Twitch channel data by handle, by search, or by whoever is live in a category right now. Each row has follower count, partner status, live viewer count, current title, category and tags, plus optional recent videos and top clips.",
        "version": "0.0",
        "x-build-id": "bOkFYI2TY9bE5IFFd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-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/goat255~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-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/goat255~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-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",
                "properties": {
                    "channels": {
                        "title": "Channels",
                        "type": "array",
                        "description": "Channel URLs or handles. Both forms work. Leave empty if you are discovering channels instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Find channels by name or topic. Returns up to 10 channels per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Collect channels that are live in a category right now, for example a game name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxChannelsPerCategory": {
                        "title": "Max channels per category",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many live channels to take from each category, ordered by viewers.",
                        "default": 30
                    },
                    "maxVideosPerChannel": {
                        "title": "Videos per channel",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Attach recent videos to each channel. 0 to skip. Up to 100.",
                        "default": 0
                    },
                    "maxClipsPerChannel": {
                        "title": "Clips per channel",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Attach top clips to each channel. 0 to skip. Up to 100.",
                        "default": 0
                    },
                    "liveChannelsOnly": {
                        "title": "Live channels only",
                        "type": "boolean",
                        "description": "Keep only channels that are streaming at the moment of the run.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Enable to spread requests across IPs on large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
