# Twitch Scraper: Channels, Streams, Clips & VODs, No Login (`transparent_meteorite/twitch-scraper`) Actor

Scrape Twitch channels, live streams, top categories, clips and VODs without a login. Get follower counts, live status, emails and socials as clean rows for lead lists and analytics.

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

## Pricing

from $1.96 / 1,000 row 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 & VODs, No Login

Twitch scraper for public data, with no login, no API key and no proxy to set up. Give it channel names and get followers, partner status, live status, current game, bio emails, social links and panel links. Or list the live streams of any game, rank the top categories by viewers, and pull VODs and clips with view counts. One Actor, six modes, one flat price per row.

It reads the same public web data the twitch.tv site shows to anyone who is not signed in. It never logs in, never touches private data and never reads chat or messages.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled input lists the 30 biggest live streams on Twitch right now in **Live streams** mode.
2. Click **Start**. A run takes a few seconds.
3. Open the **Live streams** view in the Output tab, or export JSON, CSV or Excel.
4. Switch **What to scrape** to **Channels**, **Videos** or **Clips**, add your own channel names, and run again.

### What does this Actor do?

Pick a mode. Every mode returns rows of one type, and every row carries `type`, `sourceUrl` and `scrapedAt`.

| Mode | Input it reads | One row is | Typical use |
|---|---|---|---|
| `channels` | Channel names or links | A channel profile | Streamer outreach, sponsorship vetting, audience sizing |
| `searchChannels` | Search words | A channel profile | Finding streamers by game, topic or name |
| `liveStreams` | Games (or empty for the whole site) | A live stream | Who is live now, viewer counts, language and tag filters |
| `categories` | Nothing | A category (game) | Which games have viewers but few broadcasters |
| `videos` | Channel names or links | A VOD | Content research, view-velocity checks |
| `clips` | Channel names or links | A clip | Finding a channel's most-watched moments |

### What data do you get?

**Channel rows**

| Group | Fields |
|---|---|
| Identity | `id`, `login`, `displayName`, `url`, `description`, `profileImageUrl`, `bannerImageUrl`, `primaryColorHex` |
| Audience | `followersCount`, `isPartner`, `isAffiliate`, `language` |
| Account age | `createdAt`, `accountAgeDays`, `lastBroadcastAt`, `daysSinceLastBroadcast`, `lastBroadcastTitle` |
| Live now | `isLive`, `currentViewers`, `streamTitle`, `currentGame`, `streamStartedAt`, `streamUptimeSeconds`, `streamTags` |
| Contact and links | `emails`, `socialLinks` (Discord, X, YouTube, Instagram and more), `panelLinks`, `descriptionLinks` |
| Bio parsing | `descriptionHashtags`, `descriptionMentions` |
| Nested | `recentVideos`, `topClips` (optional, no extra charge) |

**Live stream rows:** `streamId`, `broadcasterLogin`, `broadcasterDisplayName`, `broadcasterFollowers`, `isPartner`, `isAffiliate`, `title`, `viewersCount`, `game`, `gameId`, `language`, `tags`, `startedAt`, `uptimeSeconds`, `thumbnailUrl`, `url`, and `viewersPerThousandFollowers` to spot streamers who punch above their size.

**Category rows:** `rank`, `gameId`, `name`, `viewersCount`, `broadcastersCount`, `viewersPerBroadcaster`, `tags`, `boxArtUrl`, `url`.

**VOD rows:** `videoId`, `title`, `channelLogin`, `viewCount`, `lengthSeconds`, `duration`, `publishedAt`, `ageDays`, `game`, `language`, `broadcastType`, `thumbnailUrl`, `viewsPerHour`.

**Clip rows:** `clipId`, `slug`, `title`, `channelLogin`, `curatorLogin`, `viewCount`, `durationSeconds`, `createdAt`, `ageDays`, `game`, `language`, `thumbnailUrl`, `url`.

**Status rows:** a channel, game or search word that could not be read gets one `status` row (`not_found`, `invalid`, `failed` or `no_results`) with a plain message. Status rows are never charged, so you always see what happened to every input.

Dates are ISO 8601 UTC. Missing values are `null`, never a made-up number.

### Input

| Field | What it does |
|---|---|
| `mode` | `channels`, `searchChannels`, `liveStreams`, `categories`, `videos` or `clips`. |
| `channels` | Channel names, `@names` or twitch.tv links, one per line. Used by channels, videos, clips. |
| `searchQueries` | Words to find channels by. Used by searchChannels. |
| `games` | Exact category names or directory links. Empty means the top live streams of the whole site. |
| `maxResults` | Rows per input. Default 30. Up to 5,000, limited by what Twitch lists (see Limits). |
| `languages` | Live streams only: for example `EN`, `ES`, `DE`. |
| `minFollowers` | Skip channels below this size. Skipped rows are not charged. |
| `onlyLive` | Channels and search: keep only channels streaming right now. |
| `recentVideosPerChannel`, `topClipsPerChannel` | Nest up to 25 VODs or clips inside each channel row, at no extra charge. |
| `clipPeriod` | `LAST_DAY`, `LAST_WEEK`, `LAST_MONTH` or `ALL_TIME`. |
| `videoType` | `ALL`, `ARCHIVE` (past broadcasts), `HIGHLIGHT` or `UPLOAD`. |

### Example input

Channel research with nested VODs and clips:

```json
{
  "mode": "channels",
  "channels": ["shroud", "https://www.twitch.tv/pokimane", "@xqc"],
  "recentVideosPerChannel": 3,
  "topClipsPerChannel": 3,
  "clipPeriod": "LAST_MONTH"
}
```

English live streams in one game:

```json
{
  "mode": "liveStreams",
  "games": ["Just Chatting", "Valorant"],
  "languages": ["EN"],
  "minFollowers": 10000,
  "maxResults": 60
}
```

### Output sample

```json
{
  "type": "channel",
  "id": "37402112",
  "login": "shroud",
  "displayName": "shroud",
  "url": "https://www.twitch.tv/shroud",
  "description": "I'm back baby",
  "emails": [],
  "followersCount": 11287820,
  "isPartner": true,
  "isAffiliate": false,
  "language": "en",
  "createdAt": "2012-11-03T15:50:32.878Z",
  "accountAgeDays": 5127,
  "isLive": false,
  "currentViewers": null,
  "lastBroadcastAt": "2026-11-17T02:04:56.150Z",
  "daysSinceLastBroadcast": 0,
  "socialLinks": [{"name": "discord", "title": "Discord", "url": "https://discord.gg/shroud"}, {"name": "twitter", "title": "Twitter", "url": "https://twitter.com/shroud"}],
  "sourceUrl": "https://www.twitch.tv/shroud",
  "scrapedAt": "2026-11-17T20:00:00.000Z"
}
```

### Use cases

- **Streamer outreach and sponsorship:** build a list of channels in a game with followers, partner flag, language, last broadcast date, public business emails and social links, then filter by `minFollowers` and `daysSinceLastBroadcast` to drop dormant accounts.
- **Live monitoring:** schedule `liveStreams` for a game every few minutes and track viewer counts, new streamers and uptime.
- **Category research:** use `categories` to find games with a high `viewersPerBroadcaster` (an audience that few streamers serve) before you pick a game to stream.
- **Clip and VOD research:** rank a channel's clips by views for a period, or measure `viewsPerHour` on VODs to see which streams performed.
- **Market data and dashboards:** feed followers and concurrent viewers into a spreadsheet, BI tool or alert.

### Limits

- Public data only. Channels that are banned, closed or renamed are reported as `not_found`.
- Search returns about 15 channels per search word (Twitch does not page its search). Use several words to widen a list.
- Twitch shows anonymous visitors one page per list and puts every next page behind a login-grade check, which this Actor does not try to get around. So one query returns the top 30 live streams, 100 categories, 100 VODs per type or 100 clips per period. To get more, add games, languages (each language is its own top-30), VOD type All (past broadcasts, highlights and uploads) or a Max results above 100 for clips (it adds the day, week, month and all-time lists). Rows are de-duplicated.
- Followers and viewer counts are a snapshot at the time of the run.
- Emails are only those a streamer wrote in their public bio or panels.
- Chat, subscriber counts, revenue, private information and anything behind a login are not available and not collected.
- If a run reaches its time limit, it stops cleanly, keeps the rows saved and lists unread inputs in `notChecked` in the `OUTPUT` record.

### Pricing and cost control

Pay per row. Every channel, stream, category, VOD or clip row is one billable result.

| Plan | Price per row | Per 1,000 rows |
|---|---|---|
| Free | $0.0027 | $2.70 |
| Bronze | $0.00258 | $2.58 |
| Silver | $0.00233 | $2.33 |
| Gold | $0.00196 | $1.96 |
| Platinum | $0.00196 | $1.96 |
| Diamond | $0.00196 | $1.96 |

Plus a start fee of $0.002 per run. Status rows, inputs that were not found and rows removed by your filters are not charged. Nested VODs and clips inside a channel row cost nothing extra. Use **Maximum cost per run** to cap spend; the Actor stops cleanly at the limit.

Example: 100 channels with nested clips in one run is 100 rows, about $0.27 on the Free plan.

### Integrations and scheduling

Schedule runs and send the rows to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations, or call the Actor through the REST API and the Python and JavaScript clients.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~twitch-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"mode":"channels","channels":["shroud","pokimane"]}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/twitch-scraper").call(run_input={"mode": "liveStreams", "games": ["Just Chatting"], "maxResults": 30})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["broadcasterLogin"], row["viewersCount"])
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/twitch-scraper`, paste the input JSON, then map the dataset items to your sheet.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/twitch-scraper` to Claude, Cursor or any MCP client, and your agent can run this Actor as a tool.

### Fair use and legal

The Actor reads only information Twitch already shows publicly on the web to visitors who are not signed in. It does not log in, bypass any protection, or read private data. Personal data such as a public bio email is still personal data in some regions: use it in line with the privacy and anti-spam rules that apply to you. This is an independent tool, not affiliated with Twitch.

### FAQ

**Do I need a Twitch account, API key or proxy?** No.

**Can it read chat, subscribers or private information?** No. Only public channel, stream, category, VOD and clip data.

**Why is `emails` empty?** Most streamers do not put an email in the public bio or panels. The field lists only emails that are written there.

**How do I get the live streams of one game?** Set the mode to Live streams and put the exact category name in Games, for example `Just Chatting`.

**Why did a channel come back as `not_found`?** The name is misspelt, or the channel was banned, closed or renamed. The status row says which.

**How fresh is the data?** Live. Followers, viewers and live status are read at run time.

**Can I get more than 15 search results?** Twitch search returns about 15 per word. Use several search words, or use Live streams for a whole game.

### Support

Found a channel or game that reads badly? Open an issue on the Issues tab with the run URL and the input.

### Related actors

- [YouTube Channel Scraper](https://apify.com/transparent_meteorite/youtube-channel-scraper) for the same creators' YouTube channels.
- [Instagram Profile Scraper](https://apify.com/transparent_meteorite/instagram-public-profile-scraper) for their Instagram profiles and bio emails.
- [TikTok Profile Scraper](https://apify.com/transparent_meteorite/tiktok-public-profile-scraper) for their TikTok profiles.

### Changelog

- **0.1**: First private build. Channels, search, live streams, categories, VODs and clips.

# Actor input Schema

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

One row type per run. Channels, videos and clips read the names in Channels; Search channels reads Search words; Live streams reads Games (empty = top live streams of the whole site).

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

Twitch channel names or links, one per line: shroud, @pokimane or https://www.twitch.tv/xqc. Used by channels, videos and clips.

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

Words to find channels by (game, name, topic), one per line. Used by Search channels. Twitch returns about 15 channels per word.

## `games` (type: `array`):

Exact category names or links, for example Just Chatting or https://www.twitch.tv/directory/category/valorant. Used by Live streams. Leave empty for the top live streams on the whole site.

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

Per input: per channel (videos, clips), per game (live streams), per search word. Twitch gives 30 live streams, 100 categories, 100 VODs per type and 100 clips per period in one go, so larger numbers fan out over languages, VOD types and clip periods.

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

Live streams only: keep streams in these languages, for example EN, ES, DE. Each language is its own top-30 list, so adding languages gives more rows. Empty = all.

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

Channels, search and live streams: skip channels with fewer followers. Skipped rows are not charged.

## `onlyLive` (type: `boolean`):

Channels and search modes: return only channels that are streaming right now.

## `recentVideosPerChannel` (type: `integer`):

Channels mode: nest this many latest VODs (title, views, length) inside each channel row at no extra charge. 0 = none.

## `topClipsPerChannel` (type: `integer`):

Channels mode: nest this many most-viewed clips inside each channel row at no extra charge. 0 = none.

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

Clips mode and nested clips: the time window, ranked by views.

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

Videos mode: which kind of videos to list.

## Actor input object example

```json
{
  "mode": "liveStreams",
  "channels": [
    "shroud",
    "pokimane",
    "xqc",
    "ninja",
    "summit1g"
  ],
  "maxResults": 30,
  "onlyLive": false,
  "recentVideosPerChannel": 0,
  "topClipsPerChannel": 0,
  "clipPeriod": "LAST_WEEK",
  "videoType": "ALL"
}
```

# Actor output Schema

## `rows` (type: `string`):

No description

## `summary` (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": "liveStreams",
    "channels": [
        "shroud",
        "pokimane",
        "xqc",
        "ninja",
        "summit1g"
    ],
    "maxResults": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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": "liveStreams",
    "channels": [
        "shroud",
        "pokimane",
        "xqc",
        "ninja",
        "summit1g",
    ],
    "maxResults": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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": "liveStreams",
  "channels": [
    "shroud",
    "pokimane",
    "xqc",
    "ninja",
    "summit1g"
  ],
  "maxResults": 30
}' |
apify call transparent_meteorite/twitch-scraper --silent --output-dataset

```

## MCP server setup

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