# Twitch Channels & Streams Scraper: Categories, VODs & Clips (`automatic/twitch-channels-streams-scraper`) Actor

Collect public Twitch channel profiles, live streams by category, top categories and channel VOD or clip metadata without login.

- **URL**: https://apify.com/automatic/twitch-channels-streams-scraper.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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 Channels & Streams Scraper: Categories, VODs & Clips

Collect public Twitch data into a clean dataset: channel profiles with follower counts and live status, live streams in a category ranked by viewers, the top categories right now, and a channel's recent videos (VODs) and clips. No Twitch login, developer account or app keys are needed.

**What sets it apart:** five kinds of Twitch data in one Actor and one flat price of **$1 per 1,000 rows**; profiles in bulk (up to 1,000 channels in a run) with followers, partner/affiliate status, the current stream and the last broadcast in the same row; and every row collected live at run time.

### Use cases

- **Creator and influencer research:** check follower counts, partner or affiliate status and the last broadcast for a list of channels.
- **Live market snapshots:** see the top categories and who is streaming in them right now, by language.
- **Brand and esports monitoring:** schedule profile runs for teams, publishers or sponsors and track followers and live status over time.
- **Content analysis:** list a channel's recent VODs and clips with titles, durations, views and categories.
- **Lead lists for agencies:** build a sheet of streamers in a category with their channel links.

### Quick start

The Console form is prefilled with `profiles` mode. An empty input (`{}`) returns ten public channel profiles (NASA, Monterey Bay Aquarium, Bob Ross, Twitch, Twitch Gaming, Games Done Quick, ESL CS, ESL Dota 2, Riot Games and Rocket League), one row each.

Your own channels:

```json
{"mode": "profiles", "channels": ["nasa", "https://www.twitch.tv/montereyaq"], "maxResults": 20}
```

Live English streams in one category, most viewers first:

```json
{"mode": "streams", "categoryNames": ["Science & Technology"], "language": "en", "maxResults": 20}
```

A channel's latest videos:

```json
{"mode": "vods", "channels": ["nasa"], "maxResults": 20}
```

### Modes

Choose one mode per run.

| Mode | What you give | What you get |
| --- | --- | --- |
| `profiles` | `channels` (or nothing, for the ten sample channels) | One row per channel: profile, followers, partner/affiliate flags, live status, current stream, last broadcast, avatar. |
| `streams` | `categoryNames` (exact Twitch category names) | Live streams in each category, most viewers first. Optional `language`. |
| `categories` | nothing | The top categories Twitch lists right now (up to 100), with current viewers and content tags. |
| `vods` | `channels` | The channel's public videos, newest first. |
| `clips` | `channels` | The channel's clips, in Twitch's default order. |

### Input

| Name | Type | Default | What it does |
| --- | --- | --- | --- |
| `mode` | string | `profiles` | `profiles`, `streams`, `categories`, `vods` or `clips`. |
| `channels` | array | ten sample channels in `profiles` mode | Channel logins, `@logins` or `twitch.tv` links. Used by `profiles`, `vods` and `clips`. |
| `categoryNames` | array | none | Exact category names, for example `Science & Technology`. Used by `streams` only. |
| `language` | string | empty | Two-letter lowercase stream language such as `en` or `es`. Used by `streams` only. |
| `maxResults` | integer | `20` | Total rows for the run, from 1 to 1,000. Listing modes return at most 100 rows per channel or category. |

A field that does not apply to the chosen mode (for example `categoryNames` in `vods` mode), an unknown field or a malformed login stops the run at once with a message naming it. Repeated channels are read once.

### Output

Every row has `rowType` (`channel`, `stream`, `category`, `vod` or `clip`), `id` and a `url` on twitch.tv. Dates are ISO 8601; missing values are `null`. The same item is delivered once per run.

| Row type | Fields |
| --- | --- |
| `channel` | `login`, `displayName`, `description`, `avatarUrl`, `followersCount`, `isPartner`, `isAffiliate`, `isLive`, current `streamId`, `title`, `viewersCount`, `startedAt`, `categoryId`, `categoryName`, and `lastBroadcastId`, `lastBroadcastTitle`, `lastBroadcastStartedAt` |
| `stream` | `login`, `displayName`, `streamId`, `title`, `viewersCount`, `startedAt`, `categoryId`, `categoryName` |
| `category` | `name`, `viewersCount`, `tags` |
| `vod` | `login`, `title`, `durationSeconds`, `viewsCount`, `createdAt`, `categoryName` |
| `clip` | the `vod` fields plus `slug` |

### Output example

A channel row (example values from a real run):

```json
{"rowType": "channel", "id": "151920918", "url": "https://www.twitch.tv/nasa", "login": "nasa", "displayName": "NASA", "description": "Explore the universe and discover our home planet with the official NASA channel on Twitch. ", "avatarUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/8dbb66f7-0b18-4ca6-b0be-7e53aa7bf50b-profile_image-300x300.png", "followersCount": 1894574, "isPartner": true, "isAffiliate": false, "isLive": false, "lastBroadcastId": "320470471518", "lastBroadcastTitle": "U.S. Spacewalk 100", "lastBroadcastStartedAt": "2026-10-02T01:51:52.089314Z", "streamId": null, "title": null, "viewersCount": null, "startedAt": null, "categoryId": null, "categoryName": null}
```

A video row:

```json
{"rowType": "vod", "id": "2889241879", "url": "https://www.twitch.tv/videos/2889241879", "login": "nasa", "title": "NASA's SpaceX Crew-13 Arrival & Welcome Remarks", "durationSeconds": 16551, "viewsCount": 300612, "createdAt": "2026-10-01T21:15:58Z", "categoryName": "Science & Technology"}
```

### Pricing

| Event | Price |
| --- | --- |
| Row delivered (any row type) | **$1.00 per 1,000 rows** ($0.001 each) |
| Run start | **$0.005** |

The run-start event is charged per GB of memory, rounded up; the default 512 MB run is one start event. Platform usage is included.

Worked examples: the empty-input run (10 profiles) costs about **$0.015**; **1,000 channel profiles ≈ $1.01** (1,000 × $0.001 + $0.005).

### Scheduling and monitoring

Save a task with your channels and schedule it daily or hourly to build a history of followers, live status and viewers. Compare rows across runs by `id`. For live market snapshots, schedule `categories` or `streams` runs at the hours you care about; each run is a point-in-time view.

### FAQ

**How many results per category or channel?** Up to 100 per channel or category in a run (the first page Twitch lists). Profiles have no per-target limit: up to 1,000 channels per run.

**Is the data live?** Yes. Viewer counts, live status and followers are read when the run happens.

**Which formats can I export?** JSON, CSV, Excel or XML from the dataset, or read the rows through the Apify API and integrations.

**What if a channel does not exist?** It is named in the run status. If other targets returned rows, the run succeeds with them; if nothing was delivered, the run fails with the reason. A category with nobody live succeeds with zero rows.

**How long does a run take?** Usually seconds. The default timeout is 5 minutes; a run that reaches it keeps the rows already saved and lists the targets it did not reach.

### Limits

- Metadata only: no chat, viewer lists, follower or following lists, social links, subscriber-only content, or video and audio downloads. A video row does not mean the video can be played without restrictions.
- Listing modes return the first 100 rows per channel or category; older videos and clips beyond that are not collected.
- Only public channels and content.

# Actor input Schema

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

Returns only the first page (up to ~100 rows) per target; later pages are blocked by Twitch.

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

Logins, @logins or twitch.tv/login URLs. Used only for profiles, vods and clips. Profiles default to ten public channels if omitted.

## `categoryNames` (type: `array`):

Exact Twitch category names for streams, e.g. Science & Technology. Other modes reject this field when nonempty.

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

Optional lowercase two-letter stream language, e.g. en. Only for streams.

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

Global cap, limited to 100 rows per listing target. Returns only the first page (up to ~100 rows) per target; later pages are blocked by Twitch. Profiles allow up to 1,000 logins in batches.

## Actor input object example

```json
{
  "mode": "profiles",
  "language": "",
  "maxResults": 20
}
```

# Actor output Schema

## `results` (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 = {
    "mode": "profiles",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/twitch-channels-streams-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": "profiles",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/twitch-channels-streams-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": "profiles",
  "maxResults": 20
}' |
apify call automatic/twitch-channels-streams-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/twitch-channels-streams-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/BRNaKkFL8Y2RKirlY/builds/UC96fX8HPsqJCgDoO/openapi.json