# Twitch Scraper — Channels & Live Streams (`hipersoft/twitch-scraper`) Actor

Scrape Twitch channels (followers, partner status, description, live status, last broadcast) and browse live streams globally or by game (title, viewers, streamer, game). Fast clean HTTP via Twitch's public GraphQL, no login or API key. For streaming analytics and creator discovery.

- **URL**: https://apify.com/hipersoft/twitch-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.004 / item scraped

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, No Login

Scrape Twitch channels and live streams into clean structured JSON: followers, partner status, description, live status, and last broadcast for any channel — plus a browse of currently-live streams globally or by game. Fast, clean HTTP via Twitch's public GraphQL, with no login or API key. Built for streaming analytics, creator discovery, and esports monitoring.

### Features

- 📺 **Channel profiles** — `followers`, `isPartner`, `isAffiliate`, `description`, `createdAt`, and `profileImage`.
- 🔴 **Live status** — `isLive`, `liveViewers`, `liveTitle`, `liveGame`, and `liveStartedAt` in every channel record.
- ⏮️ **Last broadcast** — `lastBroadcastAt` and `lastBroadcastTitle` for channels that are currently offline.
- 🎮 **Browse live streams** — enable `includeTopStreams` for global top streams, or set `streamsGame` to filter by category.
- 🔗 **Flexible input** — accepts channel logins (`shroud`) or `twitch.tv/...` URLs.
- ⚡ **No key, no login** — clean HTTP against Twitch's public GraphQL; works without a proxy.
- 🧹 **Tidy records** — normalized text and a ready-to-use channel `url` on every row.

### What you get

Each channel is one clean JSON record:

```json
{
  "type": "channel",
  "id": "37402112",
  "login": "shroud",
  "displayName": "shroud",
  "description": "Professional gamer",
  "followers": 10500000,
  "isPartner": true,
  "isAffiliate": false,
  "createdAt": "2012-10-08T20:16:52Z",
  "profileImage": "https://static-cdn.jtvnw.net/.../profile.png",
  "isLive": true,
  "liveViewers": 24500,
  "liveTitle": "ranked grind",
  "liveGame": "VALORANT",
  "liveStartedAt": "2026-07-23T18:02:00Z",
  "lastBroadcastAt": "2026-07-22T21:10:00Z",
  "lastBroadcastTitle": "chill stream",
  "url": "https://www.twitch.tv/shroud"
}
```

Live streams (when `includeTopStreams` is on) come as `type: "stream"` records with `id`, `title`, `viewers`, `startedAt`, `broadcaster`, `broadcasterName`, `game`, and `url`.

### Input

```json
{
  "channels": ["shroud", "twitch.tv/pokimane"],
  "includeTopStreams": true,
  "streamsGame": "Just Chatting",
  "maxStreams": 30
}
```

| Field | Description |
| --- | --- |
| `channels` | Channel logins or `twitch.tv/...` URLs. |
| `includeTopStreams` | Also fetch currently-live streams. |
| `streamsGame` | Filter live streams to a game; empty = global top. |
| `maxStreams` | Max live streams (Twitch caps anonymous browse at 30). |
| `proxyConfiguration` | Optional proxy; Twitch works without one. |

### Use cases

- Track follower growth and live status for a roster of creators.
- Discover currently-live streamers in a specific game category.
- Monitor viewer counts for esports and marketing analytics.
- Verify partner/affiliate status across a set of channels.

### Pricing

Pay-per-event: you're billed a small amount per run and per item scraped — you only pay for what you get. See the **Pricing** tab for current rates.

### Notes

This Actor uses Twitch's public GraphQL endpoint and reads only public channel and stream data — no login or key. It is an independent tool and is not affiliated with, endorsed by, or connected to Twitch Interactive, Inc. Scrape public data only.

# Actor input Schema

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

Twitch channel logins or URLs (e.g. shroud, twitch.tv/pokimane), one per line.

## `includeTopStreams` (type: `boolean`):

Also fetch currently-live streams (global top, or filtered by game below).

## `streamsGame` (type: `string`):

Limit live streams to a game/category (e.g. "Just Chatting", "Grand Theft Auto V"). Empty = global top streams.

## `maxStreams` (type: `integer`):

Max live streams when Top streams is enabled. NOTE: Twitch's anonymous GraphQL caps this at 30 and integrity-gates further pagination, so top/game streams return at most 30. (The 'channels' input is unaffected.)

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

Optional. Twitch works without a proxy.

## Actor input object example

```json
{
  "channels": [
    "shroud",
    "pokimane"
  ],
  "includeTopStreams": false,
  "maxStreams": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "channels": [
        "shroud",
        "pokimane"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = { "channels": [
        "shroud",
        "pokimane",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jB5zpnhgfXXccjmHN/builds/AypiQwSnZ9lSKgYOy/openapi.json