# Twitch Scraper - Channels, Streams, Clips & Streamer Leads (`scrapesage/twitch-scraper`) Actor

Scrape Twitch channels, live streams, games/categories, clips & VODs. Get follower counts, live status, viewers, titles, tags, plus streamer leads (business email, socials & lead score). Search or paste URLs; only-new monitor mode.

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

## Pricing

from $4.00 / 1,000 channel 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 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Channels, Live Streams, Clips, VODs & Streamer Leads

Extract **complete Twitch data** — streamer profiles, live streams, games/categories, clips and VODs — and turn every channel into a **ready-to-contact influencer-marketing lead** with a business email, social links and a 0–100 lead score.

No login, no API key, no browser — fast JSON extraction straight from Twitch's own public GraphQL back end, with **inline queries** that don't break when Twitch rotates its internal query hashes (the failure mode of most other Twitch scrapers).

### Why this Twitch scraper?

Most Twitch scrapers return a thin slice (just live streams, or just a follower count) and break whenever Twitch rotates its persisted-query hashes. This actor ships the **richest dataset in the category** and is resilient by design:

| Data | Typical scrapers | This actor |
|---|---|---|
| Channel profile (followers, partner/affiliate, account age) | partial | ✅ full |
| Live status + current stream (title, game, viewers, tags, uptime, FPS) | partial | ✅ |
| Live-stream **directory** (top overall or by game, with follower counts) | partial | ✅ |
| Games / categories with live viewer counts | ❌ | ✅ |
| Clips (by channel **or** game, any time window) | partial | ✅ |
| Videos / VODs (past broadcasts, highlights, uploads) | partial | ✅ |
| Keyword **search** (channels, games, videos) | ❌ | ✅ |
| Streamer **business email** (parsed from the bio) | ❌ | ✅ opt-in |
| Social links (Instagram, YouTube, TikTok, X, Discord, Facebook…) | ❌ | ✅ opt-in |
| Lead score (0–100) per streamer | ❌ | ✅ opt-in |
| Only-new / status-change **monitor mode** | ❌ | ✅ |
| No start fee | ❌ many charge one | ✅ |

### Use cases

- **Influencer & sponsorship outreach** — find streamers by game, size or keyword, then contact them directly with `businessEmail` and their `instagram` / `youtube` / `tiktok` / `twitter` / `discord` links, ranked by `leadScore` and `followersCount`.
- **Esports & gaming market research** — track which **games** and **categories** are pulling viewers right now, and who the top live broadcasters are in each.
- **Live audience monitoring** — schedule recurring runs to watch when specific streamers go **live/offline** or switch games, and capture viewer counts over time.
- **Content & trend discovery** — pull top **clips** and **VODs** by channel or game for highlight reels, recaps and trend analysis.
- **Creator analytics** — build dashboards of follower reach, partner status, stream uptime and category mix across any list of channels.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Twitch Scraper**, pick a **mode**, enter channel names / games / a search query (or paste Twitch URLs), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Modes

| Mode | What you get | Key inputs |
|---|---|---|
| **channels** | Full streamer profiles + live status | `channelUsernames`, `startUrls` |
| **liveStreams** | Live directory (top overall or by game) | `gameNames`, `language`, `maxResults` |
| **games** | Categories with live viewer counts | `gameNames` (or top games) |
| **clips** | Top clips by channel or game | `channelUsernames` / `gameNames`, `clipPeriod` |
| **videos** | VODs (past broadcasts / highlights) | `channelUsernames`, `videoType`, `videoSort` |
| **search** | Search channels / games / videos | `searchQuery`, `searchType` |
| **streamerLeads** | Channels with lead enrichment forced on | `channelUsernames` |

### Input

```json
{
    "mode": "channels",
    "channelUsernames": ["pokimane", "jynxzi", "shroud"],
    "includeStreamerLeads": true,
    "enrichLeadWebsites": false,
    "monitorMode": false
}
```

Other examples:

```json
{ "mode": "liveStreams", "gameNames": ["VALORANT", "Just Chatting"], "language": "en", "maxResults": 30 }
```

```json
{ "mode": "clips", "channelUsernames": ["jynxzi"], "clipPeriod": "LAST_WEEK", "maxResults": 50 }
```

```json
{ "mode": "search", "searchQuery": "speedrun", "searchType": "all" }
```

- **mode** — `channels`, `liveStreams`, `games`, `clips`, `videos`, `search` or `streamerLeads`.
- **channelUsernames** — Twitch logins (the name in `twitch.tv/<name>`).
- **gameNames** — game/category names (e.g. `VALORANT`, `Just Chatting`).
- **searchQuery / searchType** — keyword search; `channels`, `games`, `videos` or `all`.
- **startUrls** — paste channel, category, clip or video URLs to auto-route.
- **maxResults** — cap per channel/game/search. *Live directory pages are capped at 30 per game by Twitch; games/clips/videos allow up to 100; channels mode is uncapped.*
- **language** — keep only matching live streams (`en`, `es`, `de`, …).
- **clipPeriod** — `LAST_DAY`, `LAST_WEEK`, `LAST_MONTH`, `ALL_TIME`.
- **videoType / videoSort** — `ARCHIVE`/`HIGHLIGHT`/`UPLOAD`/`ALL`, sorted by `TIME` or `VIEWS`.
- **includeStreamerLeads** *(default false)* — add business email + socials + lead score to each channel and output dedup'd `streamerLead` records.
- **enrichLeadWebsites** *(default false)* — crawl a streamer's linked website (home + /contact + /about) for extra emails and phones.
- **monitorMode / monitorKey** — output only new/changed items across scheduled runs.

### Output

One record per item, tagged by `type` (`channel`, `stream`, `game`, `clip`, `video`, `searchResult`, `streamerLead`). Example **channel** record with leads enabled:

```json
{
    "type": "channel",
    "id": "44445592",
    "login": "pokimane",
    "displayName": "pokimane",
    "url": "https://www.twitch.tv/pokimane",
    "description": "hi ♡ i stream sometimes 📧 Business inquiries: teampokimane@wmeagency.com",
    "profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/…-profile_image-300x300.png",
    "primaryColorHex": "#E1B5D9",
    "createdAt": "2013-06-07T14:25:22.266Z",
    "accountAgeYears": 13,
    "isPartner": true,
    "isAffiliate": false,
    "broadcasterType": "partner",
    "followersCount": 9459632,
    "isLive": false,
    "currentGame": "Just Chatting",
    "broadcastLanguage": "EN",
    "lastBroadcast": { "id": "318153812695", "title": "GRWM / AMA !", "startedAt": "2026-06-17T20:05:47Z", "game": "Just Chatting" },
    "businessEmail": "teampokimane@wmeagency.com",
    "emails": ["teampokimane@wmeagency.com"],
    "instagram": "https://www.instagram.com/pokimanelol/",
    "youtube": "https://www.youtube.com/pokimane",
    "tiktok": "https://www.tiktok.com/@poki",
    "twitter": "https://twitter.com/pokimanelol",
    "facebook": "https://www.facebook.com/pokimane",
    "socialLinksCount": 5,
    "leadScore": 90,
    "scrapedAt": "2026-06-18T00:16:52.820Z"
}
```

A **stream** record (live directory) carries `title`, `viewersCount`, `game`, `language`, `tags`, `uptimeMinutes`, `averageFps`, `thumbnailUrl` and the broadcaster's `login`, `displayName` and `broadcasterFollowersCount`.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it every few minutes/hours to track when streamers go live, watch a game's directory, or grow a lead list. Turn on **monitor mode** to pay only for new/changed items.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, Discord ping) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/twitch-scraper').call({
    mode: 'channels',
    channelUsernames: ['pokimane', 'jynxzi'],
    includeStreamerLeads: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} channels & streamer leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new streamer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get pinged when a monitored streamer goes live.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top VALORANT streamers live right now and list their contact emails" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **creator-economy & influencer lead-gen stack** — scrape every platform your prospects publish on:

- **[Spotify Scraper](https://apify.com/scrapesage/spotify-scraper)** — artists, monthly listeners, tracks, playlists & podcasts.
- **[SoundCloud Scraper](https://apify.com/scrapesage/soundcloud-scraper)** — tracks, artists, plays & creator contacts.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — channels, videos & creator email leads.
- **[Patreon Scraper](https://apify.com/scrapesage/patreon-scraper)** — creators, membership tiers & earnings estimates.
- **[Substack Scraper](https://apify.com/scrapesage/substack-scraper)** — newsletters, subscriber counts & author leads.
- **[Linktree Scraper](https://apify.com/scrapesage/linktree-scraper)** — creator bio links, emails & socials.
- **[Civitai Scraper](https://apify.com/scrapesage/civitai-scraper)** — generative-AI models, images & creator leads.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers & maker leads.

### Tips

- **Build a lead list fast**: run `liveStreams` for a game to discover who's live, copy the `broadcasterLogin`s into `channelUsernames`, then run `channels` with `includeStreamerLeads` for full contact data and lead scores.
- **Live directory depth**: Twitch caps directory pages at 30 streams per game without a browser token. Pass several `gameNames` to get 30 each, or use `channels` mode (uncapped) for a known list of streamers.
- **Monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` — channels re-emit only when they go live/offline or switch games, so you pay only for change.
- **Proxies**: the default is RESIDENTIAL because Twitch returns streamer social links only to residential IPs. For modes that don't need socials (`liveStreams`, `games`, `clips`, `videos`, `search`) you can switch to datacenter to save a little.

### FAQ

**Do I need a Twitch API key or login?** No. This actor reads Twitch's public web GraphQL back end — the same data anonymous visitors see — with no key, OAuth or browser.

**Can I get a streamer's email?** When `includeStreamerLeads` is on, the actor extracts the business/booking email that streamers publish in their own bio, plus their public social links. With `enrichLeadWebsites` it also checks a linked website. It never accesses private data.

**How do I scrape the top streamers for a game?** Use `liveStreams` mode with the game in `gameNames` — you'll get the live directory (up to 30 per game) with viewers, titles, tags and follower counts.

**Can I export to Google Sheets, CSV or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I get alerted when someone goes live?** Run `channels` mode on a [Schedule](https://docs.apify.com/platform/schedules) with `monitorMode` on; channels re-emit when their live status changes. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or Slack/Zapier step to push the alert.

**A field is null — why?** Some channels don't publish socials, a website or a current game, and offline channels have no live `stream`. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

**Is scraping Twitch legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and Twitch's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

What to scrape. <b>channels</b> = streamer profiles (followers, live status, current stream); <b>liveStreams</b> = live directory (top overall or by game); <b>games</b> = categories with viewer counts; <b>clips</b> = top clips by channel or game; <b>videos</b> = past broadcasts / highlights (VODs) by channel; <b>search</b> = search Twitch by keyword; <b>streamerLeads</b> = channels with lead enrichment forced on.

## `channelUsernames` (type: `array`):

Twitch channel logins (the name in twitch.tv/<name>) for channels, clips, videos & streamerLeads modes. Example: \["pokimane", "shroud", "jynxzi"].

## `gameNames` (type: `array`):

Game or category names for liveStreams, games & clips modes. Example: \["VALORANT", "Just Chatting", "Grand Theft Auto V"]. Leave empty in liveStreams/games mode to get the top overall directory.

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

Keyword to search for (search mode). Returns matching channels, games and/or videos depending on Search type.

## `searchType` (type: `string`):

Which result types to return in search mode.

## `startUrls` (type: `array`):

Paste Twitch URLs to auto-route: channel pages (twitch.tv/<name>), category pages (twitch.tv/directory/category/<game>), clip or video URLs. Mixed with the mode above.

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

Cap of results per channel / game / search. Live directory pages are capped at 30 per game (and 30 overall) by Twitch; games/clips/videos allow up to 100. The channels mode has no cap (one query per channel).

## `language` (type: `string`):

Optional 2-letter language code to keep only matching live streams in liveStreams mode (e.g. "en", "es", "de", "fr"). Leave empty for all languages.

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

Time window for top clips (clips mode).

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

Which VOD type to return (videos mode). Archive = past broadcasts.

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

Sort order for videos mode.

## `includeStreamerLeads` (type: `boolean`):

For channels mode: enrich each channel record with a business email (parsed from the bio), social links (Instagram, YouTube, TikTok, X, Discord, …), a website and a 0–100 lead score — and also output one dedup'd lead record (type "streamerLead") per channel. Ideal for influencer-marketing outreach.

## `enrichLeadWebsites` (type: `boolean`):

When Include streamer leads is on and a channel links a personal/business website, crawl its home + /contact + /about pages for extra emails and phone numbers. Adds a few requests per channel that has a website.

## `monitorMode` (type: `boolean`):

Remember items across runs in a named key-value store and output only NEW or CHANGED items. Channels re-emit when they go live/offline or switch games; streams, clips, videos & games are emitted only the first time they're seen. Works alongside Apify Schedules (the schedule triggers the run; monitor mode filters the output).

## `monitorKey` (type: `string`):

Name for the monitor's memory store, so separate watch-lists don't collide. Reuse the same key on each scheduled run.

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

Proxy settings. RESIDENTIAL is the default because Twitch only returns streamer social links (Instagram/YouTube/TikTok/…) to residential IPs. For modes that don't need social links (liveStreams, games, clips, videos, search) you can switch to datacenter ({ "useApifyProxy": true }) to save a little.

## Actor input object example

```json
{
  "mode": "channels",
  "channelUsernames": [
    "pokimane",
    "shroud"
  ],
  "searchType": "channels",
  "maxResults": 50,
  "clipPeriod": "LAST_WEEK",
  "videoType": "ARCHIVE",
  "videoSort": "TIME",
  "includeStreamerLeads": false,
  "enrichLeadWebsites": false,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped Twitch records as JSON items in the default dataset.

# 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 = {
    "channelUsernames": [
        "pokimane",
        "shroud"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = {
    "channelUsernames": [
        "pokimane",
        "shroud",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
  "channelUsernames": [
    "pokimane",
    "shroud"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/TkXuomF2dt4FKenVT/builds/6WQmy1avNg1v0J29G/openapi.json
