# Twitch Scraper: Channels, Streams, Clips & Games (`automation-lab/twitch-scraper`) Actor

Scrape Twitch channels, live streams, top games, clips, and VODs. Get followers, viewers, languages, business emails and social links, up to 1,000 streams or channels per run. No login, API key or browser. Filter by language and followers.

- **URL**: https://apify.com/automation-lab/twitch-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Videos, MCP servers
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 709 total users, 137 monthly users, 99.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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, streams, clips, games, and VODs

**Twitch Scraper** extracts data from [Twitch](https://www.twitch.tv) channels, live streams, top games, clips, and videos using Twitch's public API. No API key, no login, no browser needed.

Get **channel profiles** with follower counts, partner status, language, **business emails and social links**, recent VODs, and top clips. Browse up to **1,000 live streams** ranked by viewers, filtered by language and follower range (Streams by Game reaches about 100 streams per language in one category, because that is all Twitch lists). Discover **trending games** with viewer and broadcaster counts. Extract **clips** with view counts, durations, and curator info.

The easiest way to try it: [open Twitch Scraper](https://apify.com/automation-lab/twitch-scraper) on Apify, keep the default input, and click **Start**.

Built on Twitch's public GraphQL API — pure HTTP, no browser and no proxies, so most runs finish in seconds on 256 MB memory.

### Who is it for?

**Influencer marketing teams**

- Find streamers by game category, language, follower range, and partner status
- Pull business emails and social links from channel bios and panels
- Track which channels are live and what games they play
- Build outreach lists with profile data and social metrics

**Esports and gaming analysts**

- Monitor live viewership across games and categories
- Track trending games by viewer and broadcaster count
- Analyze clip performance and viral content

**Content creators and streamers**

- Research competitors in your game category
- Track top clips from channels you follow
- Monitor viewership trends for scheduling decisions

**Data journalists and researchers**

- Study Twitch viewership patterns over time
- Analyze the gaming industry landscape
- Track streamer growth and engagement metrics

### Why use Twitch Scraper?

- **No API key or login required** — uses Twitch's public endpoint
- **Pure HTTP, no browser** — runs on 256 MB memory, finishes in seconds
- **6 scraping modes** — channels, search, top streams, game streams, top games, clips
- **More than the first 30 results** — up to 1,000 live streams or channels per run, 100 clips per channel. With a language filter, Streams by Game reaches about 100 streams per language
- **Rich channel data** — followers, partner status, language, emails, social links, last broadcast, live status, VODs, clips
- **Streamer discovery filters** — language and minimum or maximum followers
- **Pay only for results** — a bad username or an empty search costs nothing
- **Export anywhere** — JSON, CSV, Excel, or push to Google Sheets, Slack, and 5,000+ apps via Zapier/Make
- **Schedule and automate** — run on a schedule via Apify's built-in scheduler
- **Full API access** — call from Node.js, Python, cURL, or any HTTP client

### What data can you extract?

#### Channel Profiles (up to 1,000 channels per run)

| Field | Description |
|-------|-------------|
| `login` | Channel username |
| `displayName` | Display name |
| `description` | Channel bio |
| `profileImageUrl` | Avatar image URL |
| `bannerImageUrl` | Banner image URL |
| `url` | Channel page URL |
| `followersCount` | Total follower count |
| `isPartner` | Twitch Partner status |
| `isAffiliate` | Twitch Affiliate status |
| `language` | Channel language code |
| `emails` | Email addresses published in the bio or panels |
| `socialLinks` | Twitter/X, Instagram, YouTube, TikTok, Discord, and other profile links |
| `isLive` | Currently streaming |
| `currentViewers` | Live viewer count |
| `streamTitle` | Current stream title |
| `currentGame` | Game being played |
| `lastBroadcastTitle` | Most recent broadcast title |
| `lastBroadcastGame` | Most recent broadcast game |
| `lastBroadcastDate` | When last broadcast started |
| `createdAt` | Account creation date |
| `recentVideos` | Recent VODs with titles, view counts, durations (5 by default, up to 100) |
| `topClips` | Top clips with view counts, URLs, curators (5 by default, up to 100) |

Search Channels returns the same profile fields except `emails`, `socialLinks`, banner, last broadcast, VODs and clips.

#### Live Streams and Game Streams

| Field | Description |
|-------|-------------|
| `broadcasterLogin` | Channel username |
| `broadcasterDisplayName` | Display name |
| `broadcasterId` | Channel ID |
| `broadcasterFollowers` | Follower count |
| `isPartner` / `isAffiliate` | Channel status |
| `title` | Stream title |
| `viewersCount` | Current viewer count |
| `game` / `gameId` | Game/category name and ID |
| `language` | Stream language code |
| `tags` | Stream tags |
| `startedAt` | Stream start time |
| `uptimeSeconds` | Seconds live when scraped |
| `thumbnailUrl` | Live preview image |
| `url` | Channel URL |

#### Top Games/Categories

| Field | Description |
|-------|-------------|
| `name` | Game/category name |
| `viewersCount` | Total viewers across all streams |
| `broadcastersCount` | Number of live channels |
| `boxArtUrl` | Game cover image |

#### Clips

| Field | Description |
|-------|-------------|
| `title` | Clip title |
| `url` | Clip URL |
| `viewCount` | View count |
| `durationSeconds` | Clip length |
| `game` | Game name |
| `channelLogin` | Source channel |
| `curatorLogin` | Who created the clip |
| `thumbnailUrl` | Clip thumbnail |

### Choose the result view for your mode

The run's **Output** tab links to focused dataset views, so each mode opens with its most useful columns visible:

| Scraping mode | Recommended view | Highlights |
|---|---|---|
| `channels`, `searchChannels` | **Channels** | Profile, followers, live status, current game, and channel URL |
| `topStreams`, `gameStreams` | **Streams** | Broadcaster, followers, viewers, game, start time, and channel URL |
| `topGames` | **Games** | Category viewers, live channels, cover art, and directory URL |
| `clips` | **Clips** | Channel, title, views, duration, game, curator, thumbnail, and clip URL |

The **Overview** link remains available as a backward-compatible channel view. All views read the same dataset and do not alter the JSON records or exports.

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

This Actor uses **pay-per-event** pricing — you pay only for what you scrape.
No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per channel** | $0.00345 | $0.003 | $0.00234 | $0.0018 |
| **Per stream/game/clip** | $0.0023 | $0.002 | $0.00156 | $0.0012 |
| **1,000 channels** | $3.45 | $3.00 | $2.34 | $1.80 |

Each run also has a one-time start fee of $0.005, charged only when the run delivers at least one result.

From 2026-11-23 the per-result prices will be: channels $0.003 (Free and Starter), $0.0027 (Scale), $0.0024 (Business and above); streams, games and clips $0.002, $0.0018, and $0.0016.

**Real-world cost examples:**

| Mode | Results | Duration | Cost (Free tier) |
|---|---|---|---|
| 2 channel profiles | 2 | ~3s | ~$0.01 |
| 30 top live streams | 30 | ~4s | ~$0.07 |
| 500 streams in one category | 500 | ~10s | ~$1.16 |
| 100 top games | 100 | ~5s | ~$0.24 |
| 100 clips from 1 channel | 100 | ~5s | ~$0.24 |

On Apify's **free plan ($5 credits)**, you can scrape approximately **1,400 channels** or **2,100 streams**.

### How to scrape Twitch data

1. Go to [Twitch Scraper](https://apify.com/automation-lab/twitch-scraper) on Apify Store
2. Select a **Scraping Mode** (Channel Profiles, Top Streams, etc.)
3. Enter the required input:
   - **Channel Profiles / Clips**: enter Twitch usernames or channel URLs
   - **Search Channels**: enter a search query
   - **Streams by Game**: enter the game name, as shown on Twitch
   - **Top Streams / Top Games**: no input needed
4. Click **Start** and wait a few seconds
5. Download results as JSON, CSV, or Excel

**Example: Scrape 3 channel profiles**

```json
{
    "mode": "channels",
    "channelUsernames": ["shroud", "pokimane", "xqc"],
    "includeVideos": true,
    "includeClips": true
}
```

**Example: Get top 30 live streams**

```json
{
    "mode": "topStreams",
    "maxResults": 30
}
```

**Example: Find German and French streamers with 1,000 to 50,000 followers**

```json
{
    "mode": "gameStreams",
    "gameName": "Just Chatting",
    "maxResults": 100,
    "languages": ["DE", "FR"],
    "minFollowers": 1000,
    "maxFollowers": 50000
}
```

**Example: Get clips from a channel**

```json
{
    "mode": "clips",
    "channelUsernames": ["shroud"],
    "maxResults": 30,
    "clipPeriod": "LAST_MONTH"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `channels` | Scraping mode: `channels`, `searchChannels`, `topStreams`, `gameStreams`, `topGames`, `clips` |
| `channelUsernames` | array | `[]` | Twitch usernames or channel URLs. Used in `channels` and `clips` modes |
| `searchQuery` | string | — | Search query for `searchChannels` mode |
| `gameName` | string | — | Game name, category URL, or slug for `gameStreams` mode (e.g., "League of Legends") |
| `maxResults` | integer | `30` | Maximum results, up to 1,000. Channel Profiles returns one row per username. Top games stop at 100 and clips at 100 per channel |
| `clipPeriod` | string | `LAST_WEEK` | Time range for clips: `LAST_DAY`, `LAST_WEEK`, `LAST_MONTH`, `ALL_TIME` |
| `includeVideos` | boolean | `true` | Include recent VODs (Channel Profiles mode) |
| `includeClips` | boolean | `false` | Include top clips (Channel Profiles mode) |
| `maxVideosPerChannel` | integer | `5` | Recent VODs per channel, up to 100 |
| `maxClipsPerChannel` | integer | `5` | Top clips per channel, up to 100 |
| `languages` | array | — | Language codes to keep, such as `EN`, `DE`. Used in streams and search modes. Streams by Game returns about 100 streams per language at most |
| `minFollowers` | integer | — | Minimum followers. Used in streams and search modes |
| `maxFollowers` | integer | — | Maximum followers. Used in streams and search modes |

### Output example

**Channel profile:**

```json
{
    "id": "37402112",
    "login": "shroud",
    "displayName": "shroud",
    "description": "I'm back baby",
    "profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/...",
    "url": "https://www.twitch.tv/shroud",
    "followersCount": 11313275,
    "isPartner": true,
    "isAffiliate": false,
    "language": "EN",
    "emails": [],
    "socialLinks": {
        "youtube": "https://www.youtube.com/shroud",
        "twitter": "https://twitter.com/shroud",
        "instagram": "https://www.instagram.com/shroud/"
    },
    "isLive": false,
    "currentViewers": null,
    "lastBroadcastTitle": "Ready or Not with friends",
    "lastBroadcastGame": "Ready or Not",
    "createdAt": "2012-11-03T15:50:32Z",
    "recentVideos": [
        {
            "id": "2724725765",
            "title": "Marathon stream",
            "viewCount": 260226,
            "durationSeconds": 27466,
            "game": "Marathon"
        }
    ]
}
```

### Tips for best results

- **Start small** — try 2-3 channels first, then scale up
- **Channel Profiles mode has no limit** — you can scrape hundreds of channels in a single run
- **Ask for what you need** — streams and channel search go up to 1,000 results, and you pay only for rows you receive
- **Use the game name shown on Twitch** — for `gameStreams` mode, use "League of Legends", not "LoL"; capitalization doesn't matter
- **Check the run status** — it tells you how many results you got against your limit, and why it stopped
- **Schedule regular runs** — track viewership trends by running the scraper on a schedule
- **Combine modes** — run multiple times with different modes to build comprehensive datasets
- **VODs and clips are optional** — disable them in Channel Profiles mode if you only need basic stats

### Integrations

- **Twitch Scraper -> Google Sheets** — export live stream rankings to a spreadsheet, updated hourly
- **Twitch Scraper -> Slack/Discord** — get alerts when specific streamers go live or hit viewer milestones
- **Twitch Scraper -> Make/Zapier** — trigger workflows when new top clips appear for tracked channels
- **Scheduled runs** — monitor game category trends daily and build historical viewership data
- **Webhooks** — process scraped channel data in real-time for influencer databases

### API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/twitch-scraper').call({
    mode: 'channels',
    channelUsernames: ['shroud', 'pokimane'],
    includeVideos: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/twitch-scraper').call(run_input={
    'mode': 'channels',
    'channelUsernames': ['shroud', 'pokimane'],
    'includeVideos': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~twitch-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "topStreams",
    "maxResults": 30
  }'
```

### 🤖 Agent and LLM workflow (Apify API / MCP-ready)

Use this actor as an agent-ready source for gaming, esports, influencer, and live-stream intelligence. It does **not** expose a native Twitch MCP endpoint; AI assistants can run it through Apify's API, Apify Integrations, or the Apify MCP server and then analyze the dataset results.

**Example agent task:** "Get the top 30 Twitch streams right now, group them by game, and identify five high-viewer channels that could fit an influencer campaign."

#### Call from an agent via API

```bash
curl "https://api.apify.com/v2/acts/automation-lab~twitch-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"topStreams","maxResults":30}'

## After the run finishes, let the agent fetch and summarize the dataset
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### Use through Apify MCP server

If your AI client supports MCP, connect the Apify MCP server and allow only this actor:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/twitch-scraper"
```

#### Configure Claude Desktop, Cursor, or VS Code

Claude Desktop, Cursor, and VS Code can use the same actor-scoped MCP endpoint. Add this JSON to your client's MCP server configuration and set `APIFY_TOKEN` in the client environment:

```json
{
    "mcpServers": {
        "twitch-scraper": {
            "url": "https://mcp.apify.com?tools=automation-lab/twitch-scraper"
        }
    }
}
```

#### Example prompts

- "Run Twitch Scraper for the top 30 streams and rank the results by `viewersCount`."
- "Get clips from `examplechannel` for the last week and summarize views by game."
- "Find channels matching an esports keyword and return their follower counts and live status."

Ask your assistant to run `automation-lab/twitch-scraper` with channel, stream, game, or clip inputs, wait for the Apify run to finish, and work with fields such as viewer counts, games, stream titles, followers, VODs, and clip metrics.

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality and responsible use

Twitch Scraper is an independent tool and is not affiliated with, endorsed by, or sponsored by Twitch.

Twitch Scraper accesses only **publicly available data** through Twitch's public API endpoints — the same data any visitor sees on twitch.tv. The scraper does not bypass any authentication, does not access private data, and does not violate CAPTCHA protections.

Web scraping of publicly available data is generally legal in the US and EU. However, you should always:

- Comply with applicable data protection laws (GDPR, CCPA)
- Use scraped data responsibly and ethically
- Avoid collecting personal data without a legitimate purpose
- Review Twitch's Terms of Service for your specific use case

### Diagnostics

When a run fails, it sends sanitized diagnostic input, the exception and Actor, build and run IDs to our private GlitchTip service so we can repair the fault. Secret fields and URL query strings are removed, and reports are kept for 30 days.

### FAQ

**How fast is Twitch Scraper?**

Very fast. Channel profiles complete in under 1 second each. Browse modes (top streams, games, clips) return results in 3-5 seconds total. A run with 30 results typically costs under $0.08.

**How much does it cost to scrape 1,000 Twitch channels?**

On the Free tier: approximately $3.45 (start fee + $0.00345 per channel). On the Scale plan ($199/mo): approximately $2.34.

**How many results can I get per run?**

Channel Profiles: as many usernames as you send. Search Channels: up to about 1,000 channels, which is where Twitch's search ends. Top Live Streams and Streams by Game: up to 1,000, ranked by viewers. With a language filter, Streams by Game stops at about 100 streams per language, because Twitch lists no more than that for one language in one category; the run's status tells you when it reached that limit, and follower filters apply to those listed streams. Top Games: 100. Clips: 100 per channel. Twitch doesn't return a full stream list in one query, so beyond the first page the actor combines pages by language and category; for 31 or more top streams the ranking is very close to, but may not exactly match, Twitch's own order.

**What if a channel username is wrong or doesn't exist?**

The run continues with the remaining usernames, and its final status names the ones it could not find. You aren't charged for missing channels. If no input is usable, the run stops with a clear message and nothing is charged.

**Are the emails and social links verified?**

No. They are exactly what the streamer published in their channel bio and panels. Many channels publish no email. Only use them in line with the laws that apply to you, and honor opt-out requests.

**Can I get historical data or past streams?**

The scraper returns up to 100 of the channel's most recent VODs (when `includeVideos` is enabled; set `maxVideosPerChannel`) and clips within a selected time range. For historical viewership data, schedule regular runs and aggregate the data over time.

### Related actors

- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — extract videos, channels, playlists, and comments
- [YouTube Transcript Scraper](https://apify.com/automation-lab/youtube-transcript) — download video transcripts and captions
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — scrape TikTok profiles, videos, and hashtags
- [Twitter/X Scraper](https://apify.com/automation-lab/twitter-scraper) — extract tweets, profiles, and followers
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — scrape posts, reels, stories, and profiles
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) — extract posts and comments from subreddits
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — scrape job listings by keyword and location

### Server API: Twitch data over HTTP

Twitch Scraper is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each lookup. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for more than 15 channels or more than 100 rows.

```bash
curl -sS "$SERVER_URL/channels?usernames=shroud,pokimane" -H "Authorization: Bearer $APIFY_TOKEN"
curl -sS "$SERVER_URL/streams?game=Just%20Chatting&maxResults=20&languages=EN" -H "Authorization: Bearer $APIFY_TOKEN"
```

| Method and path | Input | Output and charge |
| --- | --- | --- |
| `GET /` | None | `ready: true`, the routes and limits; no scraping or charge |
| `GET /channels` | Query `usernames`: 1–15 comma-separated usernames, @names or channel URLs; optional `includeVideos` (default `true`), `includeClips` (default `false`), `maxVideosPerChannel` and `maxClipsPerChannel` 1–100 (default 5), `clipPeriod` (`LAST_DAY`, `LAST_WEEK`, `LAST_MONTH`, `ALL_TIME`; default `LAST_WEEK`) | `{ok,count,results}` with one channel profile per username that exists, as in Channel Profiles mode; one Channel scraped event (`channel-scraped`) per returned channel |
| `GET /search` | Query `query`: search text (1–200 characters); optional `maxResults` 1–100 (default 30), `languages` (comma-separated codes such as `EN,ES`), `minFollowers`, `maxFollowers` | `{ok,count,results}` with channels as in Search Channels mode; one Channel scraped event (`channel-scraped`) per returned channel |
| `GET /streams` | Optional query `game` (category name, slug or directory URL; without it, the most-watched streams on Twitch), `maxResults` 1–100 (default 30), `languages`, `minFollowers`, `maxFollowers` | `{ok,count,results}` with live streams by viewers, as in Top Streams or Game Streams mode; one Stream scraped event (`stream-scraped`) per returned stream |
| `GET /games` | Optional query `maxResults` 1–100 (default 30) | `{ok,count,results}` with top categories, as in Top Games mode; one Game scraped event (`game-scraped`) per returned category |
| `GET /clips` | Query `usernames` (as above, 1–15); optional `maxResults` 1–100 (default 30), `clipPeriod` | `{ok,count,results}` with top clips shared across the channels, as in Clips mode; one Clip scraped event (`clip-scraped`) per returned clip |

No route charges a start fee. A request where nothing is found (no such channel, no matching rows, unknown category) returns an error and is free. Each request has a 60-second deadline and a 1 MiB response cap, and one server works on at most eight requests at once. Nothing is cached. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 `INVALID_INPUT`; 402 spending limit; 404 `NO_RESULTS` or unknown route; 405 wrong method; 413 `RESPONSE_TOO_LARGE`; 502 `UPSTREAM_ERROR` or charging failure; 503 server busy or stopping; 504 `TIMEOUT`. Failed requests are free. Retry only when `retryable` is true. The Server tab shows the full OpenAPI description.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/twitch-scraper/changelog.md

# Actor input Schema

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

Choose what to scrape from Twitch.

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

Twitch usernames or channel URLs (e.g., "shroud" or "https://www.twitch.tv/pokimane"). Used in Channel Profiles and Channel Clips modes.

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

Search term for finding channels. Used only in Search Channels mode. Returns up to about 1,000 channels per search.

## `gameName` (type: `string`):

Game or category name as shown on Twitch (e.g., "League of Legends" or "Just Chatting"). A category URL or slug also works. Used only in Streams by Game mode.

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

Maximum number of items to return. Channel Profiles mode returns one row per username and ignores this. Search and live streams go up to 1,000; Top Games up to 100; Clips up to 100 per channel. You are charged only for rows you receive.

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

Time range for clips. Used in "Channel Clips" mode.

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

Only keep streams and channels in these languages. Used in Top Live Streams, Streams by Game, and Search Channels modes. Streams by Game returns about 100 streams per language at most.

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

Only keep channels with at least this many followers. Used in Top Live Streams, Streams by Game, and Search Channels modes.

## `maxFollowers` (type: `integer`):

Only keep channels with at most this many followers. Useful for finding small and mid-size streamers.

## `includeVideos` (type: `boolean`):

Fetch recent VODs for each channel (Channel Profiles mode). Set the number in Recent videos per channel.

## `includeClips` (type: `boolean`):

Fetch top clips for each channel (Channel Profiles mode). Set the number in Top clips per channel.

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

How many recent VODs to include for each channel when Include Recent Videos is on. Up to 100, at no extra charge.

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

How many top clips to include for each channel when Include Top Clips is on. Up to 100, at no extra charge.

## Actor input object example

```json
{
  "mode": "channels",
  "channelUsernames": [
    "shroud",
    "pokimane"
  ],
  "searchQuery": "gaming",
  "gameName": "Just Chatting",
  "maxResults": 10,
  "clipPeriod": "LAST_WEEK",
  "includeVideos": true,
  "includeClips": false,
  "maxVideosPerChannel": 5,
  "maxClipsPerChannel": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

Backward-compatible channel results view.

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

Channel Profiles and Search Channels results.

## `streams` (type: `string`):

Top Streams and Streams by Game results.

## `games` (type: `string`):

Top Games and Categories results.

## `clips` (type: `string`):

Clips mode results.

# 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 = {
    "mode": "channels",
    "channelUsernames": [
        "shroud",
        "pokimane"
    ],
    "searchQuery": "gaming",
    "gameName": "Just Chatting",
    "maxResults": 10,
    "clipPeriod": "LAST_WEEK",
    "includeVideos": true,
    "includeClips": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "mode": "channels",
    "channelUsernames": [
        "shroud",
        "pokimane",
    ],
    "searchQuery": "gaming",
    "gameName": "Just Chatting",
    "maxResults": 10,
    "clipPeriod": "LAST_WEEK",
    "includeVideos": True,
    "includeClips": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "mode": "channels",
  "channelUsernames": [
    "shroud",
    "pokimane"
  ],
  "searchQuery": "gaming",
  "gameName": "Just Chatting",
  "maxResults": 10,
  "clipPeriod": "LAST_WEEK",
  "includeVideos": true,
  "includeClips": false
}' |
apify call automation-lab/twitch-scraper --silent --output-dataset

```

## MCP server setup

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