# Twitch Scraper — Channels, Live Streams, VODs & Clips (`fabrikit/twitch-scraper`) Actor

Scrape public Twitch data without login or API key: channel profiles (followers, partner status, live now, last and next stream, social links), live streams by category, language or tag, past broadcasts, highlights, clips and top categories. From US$1.60 per 1,000 results.

- **URL**: https://apify.com/fabrikit/twitch-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** Social media, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 channel profiles

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 Scraper — Channels, Live Streams, VODs & Clips

Twitch Scraper extracts public data from twitch.tv: channel profiles with follower counts and live status, the streams live right now, past broadcasts and highlights, clips and the top categories (games). Choose a mode, give it channel names, keywords or categories, and get one flat JSON row per result with dates in ISO 8601 and numbers as numbers. You don't need a browser, a login, a Twitch developer app or an API key. The Actor sends the same public GraphQL queries the twitch.tv website sends.

**Pricing: US$2.40 per 1,000 channel profiles; US$1.60 per 1,000 live streams, videos, clips or categories.** There's no start fee and no monthly rent.

### What you can scrape

| Mode | One row per | Sources |
|---|---|---|
| `channels` (default) | channel profile | logins / channel URLs, keyword search, or the channels live right now in a category |
| `liveStreams` | live stream | top of all of Twitch, top of each category, or the channels you list (are they live?) |
| `videos` | past broadcast, highlight or upload | channels, keyword search, single video URLs |
| `clips` | clip | channels, categories, keyword search, single clip URLs |
| `categories` | category (game) | top categories by live viewers, given categories, category search |

Filters: broadcaster language (35 Twitch languages), stream tags, minimum followers, minimum live viewers, video type (past broadcasts, highlights, uploads), video order (newest or most viewed) and clip period (24 hours, 7 days, 30 days, all time).

### Output

**Channel rows** include `login`, `displayName`, `url`, `description` (e-mails and phone numbers removed), `followers`, `broadcasterType` (partner / affiliate), `isLive`, `viewers`, `title`, `category`, `language`, `isMature` and `liveStartedAt`. They also carry `liveTags`, `lastStreamAt`, `lastStreamTitle`, `lastStreamCategory`, `nextScheduledStreamAt` (from the public schedule), `totalVideos`, `team`, `socialLinks` (the links shown on the channel page), the profile, banner and offline images, `accentColor` and `createdAt`.

**Live stream rows:** `title`, `viewers`, `startedAt`, `uptimeMinutes`, `category`, `language`, `tags`, `thumbnailUrl`, plus the channel (`login`, `displayName`, `followers`, `broadcasterType`).

**Video rows:** `videoId`, `title`, `url`, `videoType`, `createdAt`, `durationSecs`, `views`, `category`, `language`, `tags`, `thumbnailUrl`, `isRecording` and the channel.

**Clip rows:** `clipId`, `slug`, `title`, `url`, `embedUrl`, `views`, `createdAt`, `durationSecs`, `category`, `language`, `isFeatured` and the channel. They also give `videoId` and `vodUrl`, a link to the exact moment in the past broadcast.

**Category rows:** `name`, `slug`, `url`, `viewers`, `liveChannels`, `followers`, `tags`, `boxArtUrl`, `releaseDate`.

Every row also has `type`, `rank`, `source`, `sourceQuery` and `scrapedAt`. The key-value store gets `SUMMARY` (rows, requests, stop reason) and `SOURCES` (the status of every channel, search or category, for example "channel not found" or "not live right now").

### Input examples

Default run, five channel profiles:

```json
{ "mode": "channels", "channels": ["shroud", "pokimane", "ibai", "kaicenat", "xqc"], "maxItems": 20 }
```

Top 100 Spanish-language streams in Just Chatting with at least 50 viewers:

```json
{ "mode": "liveStreams", "categories": ["Just Chatting"], "languages": ["ES"], "minViewers": 50, "maxResultsPerSource": 100, "maxItems": 100 }
```

Influencer discovery. Profiles of English chess streamers live right now with 5,000+ followers:

```json
{ "mode": "channels", "categories": ["Chess"], "languages": ["EN"], "minFollowers": 5000, "maxResultsPerSource": 60 }
```

The last 50 past broadcasts of two channels, and the most viewed clips of a game this week:

```json
{ "mode": "videos", "channels": ["https://www.twitch.tv/shroud", "ibai"], "videoType": "archive", "maxResultsPerSource": 50 }
```

```json
{ "mode": "clips", "categories": ["https://www.twitch.tv/directory/category/valorant"], "clipPeriod": "week", "maxResultsPerSource": 100 }
```

### Example output

```json
{
  "type": "channel",
  "channelId": "37402112",
  "login": "shroud",
  "displayName": "shroud",
  "url": "https://www.twitch.tv/shroud",
  "followers": 11293963,
  "broadcasterType": "partner",
  "isLive": false,
  "title": "spamming runs + dailies + weeklies + getting ready for ludra",
  "category": "AION 2",
  "language": "en",
  "lastStreamAt": "2026-10-19T00:52:10.785Z",
  "nextScheduledStreamAt": "2026-10-22T18:00:00.000Z",
  "totalVideos": 1610,
  "team": "Loaded",
  "socialLinks": [{ "platform": "twitter", "title": "Twitter", "url": "https://twitter.com/shroud" }],
  "createdAt": "2012-11-03T15:50:32.878Z",
  "source": "channel",
  "sourceQuery": "shroud",
  "scrapedAt": "2026-10-21T16:54:44.923Z"
}
```

### Use cases

- **Influencer and sponsorship research:** find the channels live in your game or niche, filter them by language and followers, and compare partner status, schedule and social links.
- **Market and game analytics:** track the most watched categories, their live viewers and live channel counts. Schedule the Actor every hour to build your own time series.
- **Stream monitoring:** check whether a list of channels is live, with viewers and uptime, and send alerts to Slack or a webhook.
- **Content research and editing:** find the most viewed clips of a channel or a game for a period, with links to the exact moment in the VOD.
- **AI agents and dashboards:** clean JSON rows that an LLM agent, BI tool or spreadsheet can use directly.

### Pricing

You pay per event, with no subscription:

- `channel-result`: US$0.0024 per channel profile (1,000 profiles = US$2.40)
- `stream-result`, `video-result`, `clip-result`, `category-result`: US$0.0016 per row (1,000 rows = US$1.60; 10,000 clips = US$16)

Apify adds its small compute cost. The default run finishes in a few seconds. `maxItems` is exact, and the Actor also stops at the maximum charge you set for the run.

### Compared with alternatives

| | This Actor | Twitch Helix API | Browser-based scrapers |
|---|---|---|---|
| Setup | none | developer app + OAuth token | none |
| Profile, live status, last/next stream and socials in one row | yes | several endpoints | sometimes |
| Speed | 30-100 results per request | 100 per request, rate-limited | one page load at a time |
| Cost per 1,000 rows | US$1.60-2.40 | free, you write and host the code | usually higher |

Do you follow creators on more than one platform? Our [Substack Scraper](https://apify.com/fabrikit/substack-scraper) does the same for newsletters (posts, likes, subscriber labels). This Actor is built on its network core and adds a GraphQL client for Twitch.

### Integrations

Use the Apify API, the JavaScript or Python client, the CLI, schedules and webhooks. Export to JSON, CSV, Excel, Google Sheets, Make, Zapier, n8n or Airbyte. The Actor also works through the Apify MCP server, so AI agents can ask for "the top 20 live streams in Fortnite" or "the profiles of these channels".

### FAQ

**Is it legal?** The Actor reads only public information that twitch.tv shows to any logged-out visitor, without logging in. It never collects chat, viewer or follower lists, or the users who created clips. E-mail addresses and phone numbers are removed from bios and descriptions. Use the data responsibly and follow the privacy laws that apply to you.

**Do I need a proxy?** Usually not, because requests go out directly. If Twitch blocks the run, the Actor switches to Apify datacenter proxies and then residential proxies by itself. You can turn this off with `autoProxyFallback: false`.

**Why did a channel return no videos?** Twitch deletes past broadcasts after 7 to 60 days, depending on the channel, so only highlights and uploads stay. `SOURCES` tells you when a list was empty.

**Can I get subscriber counts, e-mails or chat?** No. Twitch doesn't publish them, and the Actor doesn't collect personal data.

**Limits?** Up to 100,000 rows per run. Lists come in Twitch's own order: viewers for live streams and categories, views for clips, Twitch relevance for search.

### En español

Twitch Scraper extrae datos públicos de Twitch sin login ni API key:

- perfiles de canales con seguidores, partner/afiliado, en vivo, último y próximo stream y redes;
- streams en vivo por categoría, idioma o etiqueta;
- VODs, highlights y clips;
- categorías más vistas.

Precio: US$2,40 por 1.000 perfiles y US$1,60 por 1.000 streams, videos, clips o categorías.

### Changelog

- **0.1 (October 2026):** first release with five modes (channels, liveStreams, videos, clips, categories), language, tag, follower and viewer filters, video type and order, clip period, and automatic proxy fallback.

# Actor input Schema

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

channels = one profile row per channel (followers, partner/affiliate, live now, last and next stream, social links). liveStreams = streams live right now (top of Twitch, of a category, or of the channels you list). videos = past broadcasts, highlights and uploads of the channels. clips = most viewed clips of channels or categories in a period. categories = categories (games) with live viewers and channels.

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

One per line: a login (shroud), a channel URL (https://www.twitch.tv/shroud), a video URL (https://www.twitch.tv/videos/123, videos mode) or a clip URL (https://clips.twitch.tv/... or twitch.tv/<channel>/clip/..., clips mode). Not used in categories mode.

## `searchQueries` (type: `array`):

Keywords for Twitch search. channels / videos / clips modes: the channels Twitch finds for each keyword (up to 'Results per source') are scraped. categories mode: categories matching the keyword. Not used for live streams.

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

Category (game) names, slugs or directory URLs: Just Chatting, valorant, https://www.twitch.tv/directory/category/minecraft. liveStreams mode: top live streams of each category. clips mode: top clips of each category. channels mode: profiles of the channels live in the category right now. categories mode: one row per category. Without any category, liveStreams and categories modes list the top of all of Twitch.

## `languages` (type: `array`):

Only streams (and category clips) in these broadcaster languages. Empty = all languages.

## `tags` (type: `array`):

Only live streams carrying all of these tags (as shown under the stream, e.g. Español, English, DropsEnabled). Live streams and channels found through categories only.

## `maxResultsPerSource` (type: `integer`):

Maximum results taken from each channel, category, keyword or top list. 0 = no limit (only maxItems).

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

Stop after this many rows in total. Exact: the run never saves or charges more.

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

Past broadcasts (archive), highlights, uploads, or all of them.

## `videoSort` (type: `string`):

Newest first or most viewed first.

## `clipPeriod` (type: `string`):

Clips created in this period, most viewed first.

## `minFollowers` (type: `integer`):

Skip channels with fewer followers. 0 = no minimum.

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

Skip live streams with fewer current viewers. 0 = no minimum.

## `maxConcurrency` (type: `integer`):

How many channels or categories are read at the same time.

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

Not needed normally: Twitch's public endpoint answers direct requests. Set a proxy only if your runs get blocked.

## `autoProxyFallback` (type: `boolean`):

If Twitch blocks two requests in a row, continue through Apify datacenter proxies and then residential proxies.

## Actor input object example

```json
{
  "mode": "channels",
  "channels": [
    "shroud",
    "pokimane",
    "ibai",
    "kaicenat",
    "xqc"
  ],
  "maxResultsPerSource": 30,
  "maxItems": 20,
  "videoType": "all",
  "videoSort": "time",
  "clipPeriod": "week",
  "minFollowers": 0,
  "minViewers": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "autoProxyFallback": true
}
```

# Actor output Schema

## `results` (type: `string`):

All rows saved during the run

## `summary` (type: `string`):

Rows saved and charged, filters, requests, network and client id used, stop reason

## `sources` (type: `string`):

For each channel, search, category or top list: status, pages read, results seen, filtered and saved, and any error

# 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": [
        "shroud",
        "pokimane",
        "ibai",
        "kaicenat",
        "xqc"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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": [
        "shroud",
        "pokimane",
        "ibai",
        "kaicenat",
        "xqc",
    ],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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 '{
  "channels": [
    "shroud",
    "pokimane",
    "ibai",
    "kaicenat",
    "xqc"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fabrikit/twitch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/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/hkggV1wohdq2sdeiV/builds/iiC6csRFK019DXo7R/openapi.json