# Twitch Streamer & Channel Analytics (`zhorex/twitch-scraper`) Actor

Extract Twitch streamer profiles, live streams, top games, clips, and VODs. 6 modes in one actor. No API key, no browser, no proxy needed. Pairs with our Kick.com Analytics for complete streaming intelligence.

- **URL**: https://apify.com/zhorex/twitch-scraper.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** Social media, Videos, Lead generation
- **Features:** Limited permissions
- **Stats:** 36 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 item 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Twitch Streamer & Channel Analytics

Extract public streamer profiles, live streams, top games, clips and VODs from Twitch — **6 modes, no API key.**

**No API key required. No browser. No proxy. Pure HTTP — fast and cheap.**

### How to scrape Twitch in 3 easy steps

1. **Go to the [Twitch Scraper](https://apify.com/zhorex/twitch-scraper) page** on Apify and click **"Try for free"**
2. **Configure your input** — choose a mode (`channel_details`, `live_streams`, `top_games`, `search`, `clips`, or `videos`), enter channel names or filters, and set the number of results
3. **Click "Run"**, wait for the scraper to finish, then **download your data** in JSON, CSV, or Excel format

No coding required. No API key. Works with Apify's free plan.

> **Streaming Intelligence Pair:** Use this alongside our [Kick.com Streamer & Channel Analytics](https://apify.com/zhorex/kick-scraper) for both streaming platforms.

### What can this actor do?

| Mode | Description | Input needed |
|------|-------------|-------------|
| `channel_details` | Full streamer profiles with followers, stream status, partner status, clips | Channel names/URLs |
| `live_streams` | Currently live streams with viewers, game, tags (at most 30 per run) | Optional game filter (a game with no live streams returns no rows) |
| `top_games` | Categories found among the top 30 live streams, ranked by viewers | Just maxResults |
| `search` | Find channels by keyword (at most 30 per run) | Search query |
| `clips` | Top clips from specific channels | Channel names + time period |
| `videos` | VODs/past broadcasts from channels | Channel names + video type |

### Twitch API alternative

The official Twitch API requires OAuth registration, client IDs, and token management. This Twitch Scraper is an alternative that extracts streamer profiles, live streams, top games, clips, and VODs from public Twitch data — no API key, no OAuth, no token refresh. Just structured data, ready to use.

### Use cases

- **Influencer marketing** — Find streamers by game, viewer count, and follower count to identify partnership opportunities
- **Esports analytics** — Track competitive gaming viewership and tournament performance across categories
- **Brand sponsorship** — Evaluate streamer reach and engagement for sponsorship decisions
- **Game publisher analytics** — Monitor your game's performance on Twitch: viewer trends, top streamers, clip virality
- **Content research** — Discover trending clips, rising categories, and emerging content formats
- **Talent scouting** — Identify rising streamers before they go mainstream using growth and engagement signals

### Scrape Twitch with Python, JavaScript, or no code

You can use the Twitch Scraper directly from the Apify Console (no code), or integrate it into your own scripts with Python or JavaScript.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("zhorex/twitch-scraper").call(run_input={
    "mode": "channel_details",
    "channelLogins": ["shroud", "pokimane", "xqc"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('zhorex/twitch-scraper').call({
    mode: 'channel_details',
    channelLogins: ['shroud', 'pokimane', 'xqc'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => console.log(item));
```

### Input examples

#### Channel Details

```json
{
    "mode": "channel_details",
    "channelLogins": ["shroud", "pokimane", "xqc"]
}
```

#### Live Streams (filtered by game)

```json
{
    "mode": "live_streams",
    "gameFilter": "VALORANT",
    "minViewers": 100,
    "maxResults": 30
}
```

#### Top Games

```json
{
    "mode": "top_games",
    "maxResults": 25
}
```

#### Search Channels

```json
{
    "mode": "search",
    "searchQuery": "valorant",
    "maxResults": 20
}
```

#### Channel Clips

```json
{
    "mode": "clips",
    "channelLogins": ["shroud", "xqc"],
    "clipsPeriod": "LAST_WEEK",
    "maxResults": 50
}
```

#### Channel Videos (VODs)

```json
{
    "mode": "videos",
    "channelLogins": ["pokimane"],
    "videoType": "ARCHIVE",
    "maxResults": 20
}
```

### Output examples

#### Channel Details output

```json
{
    "login": "shroud",
    "displayName": "shroud",
    "url": "https://www.twitch.tv/shroud",
    "description": "Former CS:GO professional player...",
    "profileImageUrl": "https://...",
    "bannerImageUrl": "https://...",
    "followersCount": 10500000,
    "isPartner": true,
    "isAffiliate": false,
    "isLive": true,
    "currentStream": {
        "title": "VALORANT RANKED",
        "viewersCount": 25000,
        "game": "VALORANT",
        "startedAt": "2026-04-09T12:00:00Z",
        "tags": ["English", "FPS"]
    },
    "lastBroadcast": {
        "title": "VALORANT RANKED",
        "startedAt": "2026-04-09T12:00:00Z"
    },
    "totalVideos": 1500,
    "topClipsThisMonth": [...],
    "createdAt": "2014-06-15T00:00:00Z",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

#### Live Streams output

```json
{
    "id": "12345678",
    "title": "RANKED GRIND",
    "viewersCount": 25000,
    "broadcasterLogin": "shroud",
    "broadcasterDisplayName": "shroud",
    "game": "VALORANT",
    "previewImageUrl": "https://...",
    "startedAt": "2026-04-09T12:00:00Z",
    "tags": ["English", "FPS"],
    "url": "https://www.twitch.tv/shroud",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

#### Clips output

```json
{
    "id": "AbCdEfGh",
    "title": "INSANE 1v5 ACE",
    "viewCount": 500000,
    "createdAt": "2026-04-05T18:00:00Z",
    "durationSeconds": 30,
    "url": "https://clips.twitch.tv/...",
    "broadcasterLogin": "shroud",
    "game": "VALORANT",
    "curatorLogin": "viewer123",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
```

### Technical advantages

- **No API key required** — no OAuth setup, no token management
- **No browser/Playwright** — Pure HTTP requests = fast execution, low memory (256 MB)
- **No proxy needed** — reads public data
- **Stops cleanly at Twitch's page limit** — when Twitch refuses a later page, the run keeps the rows it already has; if the refusal is an integrity-check error, `live_streams` and `search` say so in the run status
- **Resilient** — Each channel/query is independent; one failure doesn't crash the run

### Pricing

This actor uses pay-per-event pricing:

| Event | Price |
|-------|-------|
| 1 result scraped | **$0.02** |
| 1,000 results | **$20.00** |

No separate platform or compute charge: you pay only per result.

### How many results each mode returns

Twitch returns at most 30 items per page, and (checked in October 2026) it refuses the second page of live streams and search results with an integrity check. So `maxResults` (1-500) is not reached in every mode:

| Mode | Most rows one run returns |
|------|---------------------------|
| `channel_details` | One per entry in `channelLogins` that Twitch finds; `maxResults` is not used |
| `live_streams` (with or without `gameFilter`) | 30, the first page; `minViewers` then filters within those 30 |
| `top_games` | One per category among the top 30 live streams, up to `maxResults` |
| `search` | 30, the first page |
| `clips` / `videos` | Per channel, `maxResults` ÷ number of entries in `channelLogins` (rounded down, at least 1), fetched 30 per page; if Twitch refuses a later page, that channel stops at what it already has |

When Twitch answers the next page of `live_streams` or `search` with an integrity-check error, the run status says so.

### Limitations

- Twitch may change their backend without notice (fields may be added/removed)
- Follower counts and viewer counts are real-time snapshots, not historical
- `live_streams` and `search` return at most 30 rows per run, whatever `maxResults` says (see [How many results each mode returns](#how-many-results-each-mode-returns)); running again fetches the current first page again, not the next one
- Some fields may return null if Twitch modifies their schema

### FAQ

#### Is there a Twitch API?

Twitch has an official API (Helix), which requires OAuth app registration, client IDs, and token management. This Twitch Scraper reads the same public data shown on twitch.tv, so you need no API key, OAuth app or tokens.

#### How much does it cost to scrape Twitch?

The Twitch Scraper is priced per result: **$0.02 ($20 per 1,000).** No separate platform or compute charge. You can start with Apify's free plan, which includes $5 of monthly credits.

#### Can I scrape Twitch in Python?

Yes. Install the Apify Python client (`pip install apify-client`), then use the `ApifyClient` to call the `zhorex/twitch-scraper` actor. See the Python code example above.

#### Is scraping Twitch legal?

This scraper accesses publicly available data — the same information visible to anonymous visitors of twitch.tv. Always review your local laws and Twitch's terms of service.

#### What does this Twitch scraper cover?

The [Twitch Scraper by Zhorex](https://apify.com/zhorex/twitch-scraper) supports 6 modes (channel details, live streams, top games, search, clips, and videos), requires no API key, and runs without a browser or proxy.

### Integrations & data export

The Twitch Scraper integrates with your existing workflow tools:

- **Google Sheets** — Send scraped Twitch data directly to a spreadsheet
- **Zapier / Make / n8n** — Automate workflows triggered by new Twitch data
- **REST API** — Call the actor programmatically and retrieve results via Apify's REST API
- **Webhooks** — Get notified when a scraping run finishes and process data in real time
- **Data formats** — Download results in JSON, CSV, Excel, XML, or RSS

### More scrapers by Zhorex

#### Streaming

- [Kick.com Streamer & Channel Analytics](https://apify.com/zhorex/kick-scraper) — The streaming pair: Kick.com profiles, live streams, clips, and categories

#### Chinese Digital Intelligence Suite

- [Bilibili Scraper](https://apify.com/zhorex/bilibili-scraper) — China's YouTube (video, danmaku, creator analytics)
- [RedNote (Xiaohongshu) Scraper](https://apify.com/zhorex/rednote-xiaohongshu-scraper) — China's Instagram + Pinterest (social commerce)
- [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) — China's Twitter (microblogging, trending topics)

#### B2B Reviews

- [G2 Reviews Scraper](https://apify.com/zhorex/g2-reviews-scraper) — B2B software reviews and ratings

#### Other Tools

- [Perplexity AI Scraper](https://apify.com/zhorex/perplexity-ai-scraper) — AI-powered search results
- [Tech Stack Detector](https://apify.com/zhorex/tech-stack-detector) — Detect technologies used by websites
- [Telegram Channel Scraper](https://apify.com/zhorex/telegram-channel-scraper) — Public Telegram channel messages
- [Phone Number Validator](https://apify.com/zhorex/phone-number-validator) — Validate and format phone numbers

**Personal data.** Some fields describe people (streamer logins, display names, profile descriptions, profile and banner images, follower counts and account creation dates, and the login and display name of the user who made each clip). Under Apify's [Standard Actor Contract](https://docs.apify.com/legal/standard-actor-contract) you, as the person running the Actor, decide what is collected and are the controller of that data: you need a lawful basis (e.g. GDPR) and must respect Twitch's terms. Collect only what you need and delete what you no longer need. Do not use the output to harass, stalk or build profiles of private individuals.

Not affiliated with, endorsed by or sponsored by Twitch. Names are used only to describe the data source.

***

💡 Reviews, good or bad, help other users decide: [leave a rating](https://apify.com/zhorex/twitch-scraper/reviews).

# Actor input Schema

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

Select what data to extract from Twitch.

## `channelLogins` (type: `array`):

Twitch usernames or full URLs (e.g., 'shroud' or 'https://www.twitch.tv/shroud'). Used in channel_details, clips, and videos modes.

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

Keyword to search for channels (used in search mode only).

## `gameFilter` (type: `string`):

Filter live streams by game name (e.g., 'Fortnite', 'Just Chatting'). Used in live_streams mode. If no live stream matches the game, the run returns no rows and charges nothing for results.

## `minViewers` (type: `integer`):

Only return live streams with at least this many viewers. Used in live_streams mode.

## `clipsPeriod` (type: `string`):

Time range for fetching clips. Used in clips mode.

## `videoType` (type: `string`):

Type of videos to fetch. ARCHIVE = past broadcasts, HIGHLIGHT = highlights, UPLOAD = uploads. Used in videos mode.

## `maxResults` (type: `integer`):

How many results to ask for (1-500). Twitch hands out at most 30 per page and currently refuses the second page of live streams and search results, so live_streams (with or without gameFilter) and search return at most 30; top_games returns at most one row per category among the top 30 live streams. In clips and videos each channel returns at most maxResults divided by the number of entries in channelLogins (rounded down, at least 1). Not used in channel_details (one row per channel found).

## Actor input object example

```json
{
  "mode": "channel_details",
  "channelLogins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "searchQuery": "valorant",
  "minViewers": 0,
  "clipsPeriod": "LAST_WEEK",
  "videoType": "ARCHIVE",
  "maxResults": 50
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with all rows this run produced

# 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 = {
    "channelLogins": [
        "shroud",
        "pokimane",
        "xqc"
    ],
    "searchQuery": "valorant"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/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 = {
    "channelLogins": [
        "shroud",
        "pokimane",
        "xqc",
    ],
    "searchQuery": "valorant",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/twitch-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channelLogins": [
    "shroud",
    "pokimane",
    "xqc"
  ],
  "searchQuery": "valorant"
}' |
apify call zhorex/twitch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zhorex/twitch-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/s3bOtHvwEF0IKpWQy/builds/A7ZVDL15otLOhj22E/openapi.json