# Twitch Analytics: Streamer Stats & Best Games to Stream (`precious_bathmat/twitch-channel-game-analytics`) Actor

Twitch streamer and game analytics: followers, average views per stream, hours and streams per week, games played and top clips for any channel, plus how crowded each game is and which games give smaller streamers the most viewers. No login.

- **URL**: https://apify.com/precious_bathmat/twitch-channel-game-analytics.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 reports

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 Analytics: Streamer Stats & Best Games to Stream

Two answers from **Twitch**, no login needed:

1. **How is a channel really doing?** Followers, **average views per stream**, views per 1,000 followers, **streams and hours per week**, which games it plays, its best broadcast, its top clips, and whether it is live now.
2. **Which game should I stream?** For any game: live viewers and streamers, **viewers per streamer**, how much the **top 10 streams** take, what a typical stream gets **outside the top 10**, the languages watched and the size of the channels in the top 100. Plus a comparison of Twitch's **top categories right now**: most watched, most crowded and **best for smaller streamers**.

### What does this Twitch scraper do?

```
Minecraft · live now
 54,097 viewers across 3,150 streamers   17.2 viewers per streamer
 top 10 streams hold 61%                 6.8 per streamer outside them
 66% of viewers watch in Spanish

Best for smaller streamers right now (viewers per streamer outside the top 10)
 Slots 184 · Rust 58 · ASMR 41 · Grand Theft Auto V 30
```

1. Enter **channels** ("shroud", or a twitch.tv link) and/or **games** ("Valorant", "lol", "cs2", or a category link).
2. Optionally compare the **top categories** (up to 100) and filter games by **stream language**.
3. The Actor reads Twitch's public data and returns **one report per channel and game**, plus videos, live streams and categories as CSV.

### Who is it for?

- **Brands and agencies**: check a streamer's real reach (views per stream, not just followers) before a sponsorship
- **Streamers**: find games where viewers are not all taken by the top channels, and benchmark against rivals
- **Esports and games marketers**: watch a game's audience, languages and top creators
- **Analysts**: track categories over time with a schedule

### What data do you get?

**Channel report**

| Field | What it tells you |
|---|---|
| `followers`, `partner`, `affiliate`, `accountAgeYears` | Size and status |
| `averageViewsPerBroadcast`, `medianViewsPerBroadcast`, `viewsPerThousandFollowers` | Real reach per stream |
| `streamsPerWeek`, `hoursPerWeek`, `averageStreamHours`, `periodDays` | How often and how long they stream |
| `gamesByHours` | Games played, by share of hours |
| `bestBroadcast`, `topClipsLastMonth` | Their biggest stream and clips |
| `liveNow`, `liveViewers`, `liveGame`, `lastStreamAt`, `daysSinceLastStream` | Right now |

**Game report**

| Field | What it tells you |
|---|---|
| `liveViewers`, `liveStreamers`, `gameFollowers` | Size of the category now |
| `viewersPerStreamer`, `viewersPerStreamerOutsideTop10`, `top10ViewersSharePercent` | How crowded it is, and what a typical stream gets |
| `medianViewersRank11to100`, `smallestStreamInTop100` | What it takes to reach the top 100 |
| `viewersByLanguage`, `channelSizesInTop100` | Who watches, and how big the channels are |
| `topStreams` | The 10 biggest live streams |

**Top categories**: `mostWatched`, `mostCrowded`, `bestForSmallerStreamers`, and every category in `TOP_GAMES_CSV`.

**Files**: `VIDEOS_CSV` (recent videos per channel with views and length), `STREAMS_CSV` (top live streams per game with viewers and followers), `TOP_GAMES_CSV`.

### Example: 30 September 2026, around 1:00 UTC

Two runs 20 minutes apart (the second: **8 reports in 12 seconds**):

| Channel | Followers | Avg views / stream | Streams / week | Hours / week |
|---|---|---|---|---|
| xQc | 12.6M | **947,407** | 6.3 | 64.5 |
| shroud | 11.3M | 349,694 | 5.3 | 43.0 |
| pokimane | 9.4M | 162,638 | 1.3 | 3.2 |

| Game | Viewers | Streamers | Per streamer | Outside top 10 | Top 10 share |
|---|---|---|---|---|---|
| Just Chatting | 223,016 | 5,596 | 39.9 | **27.5** | 31% |
| League of Legends ("lol") | 70,661 | 2,522 | 28.0 | 16.5 | 42% |
| Minecraft | 54,097 | 3,150 | 17.2 | 6.8 | 61% |
| VALORANT | 41,668 | 3,389 | 12.3 | 8.8 | 29% |
| Counter-Strike ("cs2") | 30,119 | 1,445 | 20.8 | 13.8 | 34% |

The top 100 categories held **1.7 million viewers across 75,067 streamers**.

### Pricing

**$0.02 per report** (channel, game or top-categories comparison) and **$0.001 per row** saved (video, live stream or category).

A channel with 25 videos saved costs **$0.045**; set "Rows to save per report" to 0 and it is **$0.02**. The run above cost **$0.44** for 8 reports and 275 rows.

### Good to know

- **Streaming figures come from saved past broadcasts.** Twitch deletes them after 7 to 60 days and some channels hide them, so `periodDays` shows how far back the figures go. A channel with none gets a note instead.
- **Game detail comes from the top ~100 live streams**; viewer and streamer totals are Twitch's own for the whole category. With a language filter, the figures cover those streams only.
- **Live numbers change by the hour.** Schedule the Actor to compare times of day or days of the week.
- **Shorthand works**: lol, cs2, gta, wow, apex, r6, dota, pubg, ow… A name Twitch does not know is looked up with Twitch's own category search.
- **No personal data**: channel names are public; emails and phone numbers in bios and titles are removed.

### Input

| Field | Meaning |
|---|---|
| **Channels** | Names or links |
| **Games and categories** | Names, shorthand or category links |
| **Top categories to compare** | 0 to 100 (50 when nothing else is given) |
| **Stream languages** | Optional, for game reports: EN, ES, PT... |
| **Recent videos per channel** | 5 to 100 |
| **Live streams per game** | 10 to 100 |
| **Rows to save per report** | 0 to 100 |

### Integrations

Export to JSON, CSV, Excel or Google Sheets, or connect through the Apify API, webhooks, Make, Zapier and n8n. **Schedule it hourly or daily** to build your own history of a game's audience or a streamer's reach.

# Actor input Schema

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

Twitch channel names or links, one per line: "shroud", "https://www.twitch.tv/pokimane". One report per channel.

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

Game or category names, or category links: "Valorant", "Just Chatting". One report per game on how crowded it is.

## `topGames` (type: `integer`):

Also compare Twitch's top N categories right now (0 to 100): most watched, most crowded, best for smaller streamers. Used automatically (50) when no channel or game is given.

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

Optional two-letter codes, e.g. EN, ES, PT: game reports then cover streams in these languages only.

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

How many recent videos to read per channel (5 to 100); past broadcasts among them give the streaming figures.

## `streamsPerGame` (type: `integer`):

How many of a game's top live streams to read (10 to 100).

## `maxRowsPerReport` (type: `integer`):

Videos (channels) or live streams (games) saved to the files, 0 to 100. Reports always use everything read. Charged per row; the top-categories list is saved in full.

## Actor input object example

```json
{
  "channels": [
    "shroud",
    "pokimane"
  ],
  "games": [
    "Valorant"
  ],
  "topGames": 30,
  "videosPerChannel": 30,
  "streamsPerGame": 100,
  "maxRowsPerReport": 25
}
```

# Actor output Schema

## `reports` (type: `string`):

One row per channel, game and top-categories comparison.

## `videos` (type: `string`):

Recent videos per channel: type, title, views, hours, date, game, link.

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

Top live streams per game: channel, viewers, followers, language, title, link.

## `topGames` (type: `string`):

Viewers, streamers, viewers per streamer and top-10 share for each top category.

## `summary` (type: `string`):

Source, problems and the limits of the data.

# 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"
    ],
    "games": [
        "Valorant"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/twitch-channel-game-analytics").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",
    ],
    "games": ["Valorant"],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,precious_bathmat/twitch-channel-game-analytics"
        }
    }
}
```

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/zwziFthdfK736kBrR/builds/iARtpnADQ6Sl8lt4O/openapi.json