# Twitch Streams & Channels Scraper (`fetch_cat/twitch-streams-channels-scraper`) Actor

Export public Twitch streams, channels, categories, viewer metrics, account details, recent videos, and top clips through the official Twitch API.

- **URL**: https://apify.com/fetch\_cat/twitch-streams-channels-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

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/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 Streams & Channels Scraper

Export public Twitch streams and channels with live viewer metrics, stable IDs, account details, recent VODs, and top clips through an authorized Twitch application.

Twitch Streams & Channels Scraper turns channel URLs, category names, and search terms into structured rows for creator discovery, live-stream monitoring, gaming research, dashboards, and API workflows. You do not need to supply a Twitch login, cookies, or API credentials.

> **Unofficial integration:** This Actor is independently maintained and is not affiliated with, sponsored by, or endorsed by Twitch.

### What does this Actor do?

- **Live stream discovery:** Export top streams or streams from categories such as Just Chatting, Minecraft, and League of Legends.
- **Channel search and profiles:** Find live and offline channels and collect stable Twitch IDs, display names, profile images, account dates, and broadcaster type.
- **Live metrics:** Collect viewer counts, stream titles, game/category IDs, languages, tags, timestamps, thumbnails, and mature-content flags.
- **Optional content enrichment:** Attach up to five recent public VODs and five public clips to selected channel rows.
- **Reliable automation:** Cursor pagination, global deduplication, bounded retries, progressive saves, pending-work checkpoints, and a machine-readable run summary.
- **Flexible export:** Download JSON, CSV, Excel, XML, or use the Apify API, schedules, webhooks, and MCP.

### Who is it for?

- **Creator and influencer teams** discovering Twitch channels for sponsorship research.
- **Game studios and esports analysts** monitoring live category audiences and streamer activity.
- **Content teams** comparing recent public VODs and clips across channels.
- **Researchers and data journalists** collecting repeatable public Twitch snapshots.
- **Developers and AI agents** integrating Twitch stream and channel data through API or MCP.

### Example input

```json
{
  "categories": ["Just Chatting", "Minecraft"],
  "searchTerms": ["vtuber"],
  "includeOfflineChannels": true,
  "includeVideos": true,
  "videosPerChannel": 3,
  "includeClips": true,
  "clipsPerChannel": 3,
  "maxEnrichedChannels": 20,
  "maxItems": 75
}
```

### Example output

```json
{
  "url": "https://www.twitch.tv/examplechannel",
  "channelId": "123456789",
  "channelName": "examplechannel",
  "displayName": "ExampleChannel",
  "broadcasterType": "partner",
  "channelCreatedAt": "2020-01-15T12:00:00Z",
  "isLive": true,
  "isMature": false,
  "streamId": "987654321",
  "streamTitle": "Ranked matches with viewers",
  "categoryId": "27471",
  "category": "Minecraft",
  "viewerCount": 1245,
  "startedAt": "2026-07-20T10:00:00Z",
  "language": "en",
  "tags": ["English", "Survival"],
  "thumbnailUrl": "https://static-cdn.jtvnw.net/previews-ttv/live_user_examplechannel-440x248.jpg",
  "profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/example-profile.png",
  "offlineImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/example-offline.png",
  "followersText": null,
  "followersCount": null,
  "channelDescription": "Public Twitch channel description.",
  "recentVideos": [
    {
      "id": "2468013579",
      "title": "Recent broadcast",
      "url": "https://www.twitch.tv/videos/2468013579",
      "viewCount": 4321,
      "duration": "2h14m8s"
    }
  ],
  "topClips": [
    {
      "id": "InterestingClipSlug",
      "title": "Top play",
      "url": "https://clips.twitch.tv/InterestingClipSlug",
      "viewCount": 9800,
      "durationSeconds": 28.4
    }
  ],
  "warnings": [],
  "sourceType": "category",
  "sourceValue": "Minecraft",
  "scrapedAt": "2026-07-20T11:00:00.000Z"
}
```

### Ready-to-run examples

- [Export live Twitch channels from Just Chatting](https://apify.com/fetch_cat/twitch-streams-channels-scraper/examples/twitch-just-chatting-live-channels)
- [Find live Minecraft Twitch channels](https://apify.com/fetch_cat/twitch-streams-channels-scraper/examples/twitch-gaming-channel-search)
- [Find live and offline Twitch music channels](https://apify.com/fetch_cat/twitch-streams-channels-scraper/examples/twitch-offline-inclusive-music-discovery)
- [Export Twitch channels with recent VODs and clips](https://apify.com/fetch_cat/twitch-streams-channels-scraper/examples/twitch-channel-vod-clip-enrichment)

Each example is a tested public task with a bounded input, selected output view, and a dedicated landing page. Duplicate one into your Apify account to run it as-is or customize the input.

With no channel, category, or search input, the Actor exports the current top live Twitch streams.

### Input settings

| Setting | API key | Description |
| --- | --- | --- |
| Twitch URLs | `startUrls` | Up to 100 public channel, category, or Twitch search URLs. |
| Categories or games | `categories` | Up to 100 category names. The legacy `games` API alias remains accepted. |
| Channel search terms | `searchTerms` | Up to 100 public Twitch channel searches. |
| Maximum saved channels | `maxItems` | Global unique-row limit from 1 to 10,000. Default: 20. |
| Include offline channels | `includeOfflineChannels` | Include offline profiles from direct channel and search inputs. Default: true. |
| Include recent VODs | `includeVideos` | Attach public archived broadcasts. Default: false. |
| VODs per channel | `videosPerChannel` | Attach 1–5 recent broadcasts. Default: 3. |
| Include top clips | `includeClips` | Attach public clips. Default: false. |
| Clips per channel | `clipsPerChannel` | Attach 1–5 clips. Default: 3. |
| Maximum enriched channels | `maxEnrichedChannels` | Bound optional VOD/clip requests to 1–100 channels. Default: 20. |
| Allow empty results | `allowEmptyResults` | Permit a successful zero-row monitoring run. Default: false. |
| Active work deadline | `maxRunSeconds` | Stop admitting work after 60–270 seconds while preserving cleanup time. Default: 240. |
| Proxy | `proxyConfiguration` | Optional compatibility setting. Direct authorized API traffic is the default. |

### Output fields

| Field | Description |
| --- | --- |
| `url`, `channelId`, `channelName`, `displayName` | Canonical URL plus stable and human-readable channel identity. |
| `broadcasterType`, `channelCreatedAt` | Partner/affiliate type and account creation time when returned. |
| `isLive`, `isMature`, `streamId`, `streamTitle` | Current live status and stream identity. |
| `categoryId`, `category`, `viewerCount`, `startedAt` | Current game/category and live audience metrics. |
| `language`, `tags` | Public stream or channel classification metadata. |
| `thumbnailUrl`, `profileImageUrl`, `offlineImageUrl` | Public stream preview and channel imagery. |
| `channelDescription` | Public channel biography. |
| `followersText`, `followersCount` | Compatibility keys. They are `null` without broadcaster-authorized follower access. |
| `recentVideos` | Optional nested VOD metadata: IDs, titles, dates, URLs, views, language, type, and duration. |
| `topClips` | Optional nested clip metadata: IDs, URLs, titles, creators, views, timestamps, duration, and VOD offset. |
| `warnings` | Row-specific non-fatal enrichment or limit warnings. |
| `sourceType`, `sourceValue`, `scrapedAt` | Provenance and collection time. |

The default key-value store also contains `RUN_SUMMARY` and `PENDING_WORK`. These records report target failures, warnings, processed work, deadline state, and the latest idempotent cursor checkpoint without adding paid dataset rows.

### Pricing

The Actor charges one `start` event per valid run and one `item` event for each stream or channel row successfully saved. Optional VODs and clips are nested in the paid parent row and do not create additional result events. Failed targets and unsaved enrichment are not charged as items.

| Apify pricing tier | Start | Saved `item` row | Approximate 1,000 rows |
| --- | ---: | ---: | ---: |
| Free | $0.005 | $0.000575 | $0.575 + start |
| Starter / Bronze | $0.005 | $0.000500 | $0.500 + start |
| Scale / Silver | $0.005 | $0.000390 | $0.390 + start |
| Business / Gold | $0.005 | $0.000300 | $0.300 + start |
| Platinum | $0.005 | $0.000200 | $0.200 + start |
| Diamond | $0.005 | $0.000140 | $0.140 + start |

### Use as a Twitch data API

Replace `YOUR_TOKEN` with your Apify API token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/twitch-streams-channels-scraper').call({
  categories: ['Minecraft'],
  includeVideos: true,
  includeClips: true,
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('fetch_cat/twitch-streams-channels-scraper').call(run_input={
    'categories': ['Minecraft'],
    'includeVideos': True,
    'includeClips': True,
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~twitch-streams-channels-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["Minecraft"],"includeVideos":true,"includeClips":true,"maxItems":50}'
```

### MCP and AI agents

This Actor works through the official Apify MCP server. A focused server URL exposes only this Actor:

```text
https://mcp.apify.com?tools=fetch_cat/twitch-streams-channels-scraper
```

Claude CLI setup:

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

JSON configuration:

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

Example prompts:

- “Export 50 live Minecraft Twitch channels and rank them by current viewers.”
- “Find Twitch channels matching speedrun, include recent VODs and clips for the first 20, and summarize content themes.”
- “Check these five Twitch channel URLs every hour and highlight changes in live status, title, category, and viewers.”

### Schedule Twitch monitoring

Use an Apify schedule for hourly, daily, or weekly snapshots. Keep the same input and export destination so stable `channelId`, `streamId`, `categoryId`, and `scrapedAt` values can support change tracking. Enable `allowEmptyResults` only when a zero-match interval is a valid monitoring outcome.

### Tips for better results

- Use exact Twitch category names when possible.
- Start with a small `maxItems` and `maxEnrichedChannels` when testing VOD or clip enrichment.
- Set `includeOfflineChannels: false` for live-only creator lists.
- Multiple inputs share one global result limit and are deduplicated by stable Twitch channel ID.
- Direct authorized API access is normally the fastest and least expensive route; a residential proxy is not required.

### Limits and responsible use

- The Actor exports public metadata through an authorized Twitch application. It does not collect Twitch passwords, cookies, chat history, subscriptions, messages, or private account data.
- Twitch follower totals require qualifying broadcaster/moderator authorization. The compatibility fields `followersCount` and `followersText` therefore remain `null` for ordinary public lookups.
- Recent VOD and clip arrays may be empty when a channel has no public content or Twitch does not return it.
- Viewer counts and live state are point-in-time values and can change immediately after collection.
- Review [Twitch’s Terms of Service](https://www.twitch.tv/p/en/legal/terms-of-service/), privacy expectations, and applicable laws. Do not use exported data for spam, harassment, or prohibited profiling.

### FAQ

#### Do users need a Twitch account or API key?

No. The Actor operator supplies an authorized Twitch application. Run inputs never ask customers for Twitch credentials, login cookies, or access tokens.

#### Can it export Twitch clips and VODs?

Yes. Enable `includeClips` or `includeVideos`. Metadata is nested in each channel row; the Actor does not download media files.

#### Why are follower counts null?

Twitch restricts follower totals to qualifying broadcaster/moderator authorization. The Actor does not collect that user authorization, so it avoids presenting an unsupported or stale total.

#### Why did my run fail instead of returning an empty dataset?

Empty success often hides invalid categories, removed channels, credential problems, or source changes. The default is therefore to fail with diagnostics. Set `allowEmptyResults: true` only for a workflow where zero matches are expected.

#### Can I export to CSV, Excel, JSON, or an API?

Yes. Apify datasets support CSV, Excel, JSON, XML, RSS, HTML table, API access, webhooks, and integrations.

#### Can I monitor Twitch channels on a schedule?

Yes. Use Apify schedules and stable channel IDs to compare viewer counts, live state, stream titles, and categories over time.

### Related Actors

- [YouTube Channel Videos Scraper](https://apify.com/fetch_cat/youtube-channel-videos-scraper)
- [YouTube Video Details Scraper](https://apify.com/fetch_cat/youtube-video-details-scraper)
- [TikTok Profile Scraper](https://apify.com/fetch_cat/tiktok-profile-scraper)
- [Instagram Profile Posts Scraper](https://apify.com/fetch_cat/instagram-profile-posts-scraper)
- [YouTube Search Results Scraper](https://apify.com/fetch_cat/youtube-search-results-scraper)

### Support

If a run fails or the output looks wrong, open an issue or report a bug from the Actor page. Include the Apify run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL from Twitch, category, or search term. Do not include Twitch application secrets or access tokens.

# Actor input Schema

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

Paste public Twitch channel URLs, category URLs, or search URLs. Up to 100 URLs per run.

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

Enter up to 100 Twitch category names, such as Just Chatting, Minecraft, or League of Legends. The closest documented category match is used when an exact match is unavailable.

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

Enter up to 100 terms for finding live and offline public Twitch channels.

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

Maximum number of unique stream or channel rows saved across every input and page.

## `includeOfflineChannels` (type: `boolean`):

Include offline profiles found through channel URLs and channel search. Category and top-stream results are live only.

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

Add recent public archived broadcasts to each enriched channel row. Disabled by default to minimize requests and runtime.

## `videosPerChannel` (type: `integer`):

Number of recent public archived broadcasts to attach when VOD enrichment is enabled.

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

Add top public clips to each enriched channel row. Disabled by default to minimize requests and runtime.

## `clipsPerChannel` (type: `integer`):

Number of top public clips to attach when clip enrichment is enabled.

## `maxEnrichedChannels` (type: `integer`):

Caps the number of channels that receive VOD or clip requests. Base channel rows continue after this limit.

## `allowEmptyResults` (type: `boolean`):

Enable only when zero matches are an expected monitoring outcome. Otherwise, an empty dataset fails with an actionable message.

## `maxRunSeconds` (type: `integer`):

Maximum seconds spent admitting Twitch work. The Actor stops earlier when needed to reserve at least 30 seconds for persistence and cleanup.

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

Optional compatibility setting. The authorized Twitch API normally works directly and does not require residential proxy traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.twitch.tv/directory/category/just-chatting"
    },
    {
      "url": "https://www.twitch.tv/twitch"
    }
  ],
  "categories": [
    "Just Chatting"
  ],
  "searchTerms": [
    "minecraft"
  ],
  "maxItems": 20,
  "includeOfflineChannels": true,
  "includeVideos": false,
  "videosPerChannel": 3,
  "includeClips": false,
  "clipsPerChannel": 3,
  "maxEnrichedChannels": 20,
  "allowEmptyResults": false,
  "maxRunSeconds": 240,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `enrichment` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `pendingWork` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.twitch.tv/directory/category/just-chatting"
        },
        {
            "url": "https://www.twitch.tv/twitch"
        }
    ],
    "categories": [
        "Just Chatting"
    ],
    "searchTerms": [
        "minecraft"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/twitch-streams-channels-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 = {
    "startUrls": [
        { "url": "https://www.twitch.tv/directory/category/just-chatting" },
        { "url": "https://www.twitch.tv/twitch" },
    ],
    "categories": ["Just Chatting"],
    "searchTerms": ["minecraft"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/twitch-streams-channels-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 '{
  "startUrls": [
    {
      "url": "https://www.twitch.tv/directory/category/just-chatting"
    },
    {
      "url": "https://www.twitch.tv/twitch"
    }
  ],
  "categories": [
    "Just Chatting"
  ],
  "searchTerms": [
    "minecraft"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/twitch-streams-channels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/m9Hdkd5lOUo7kLg58/builds/nfuiTJzjqQNnBZgHp/openapi.json