# Twitch Stats Tracker — Top Games, Live Streams & Channel Growth (`northbell/twitch-stats-tracker`) Actor

Twitch stats with growth: the top 100 games with rank and viewer changes, the biggest live streams (by game or language), and channel followers, live status and viewers. Run it again or on a schedule to get followers per day and rank changes since the last run. No login, no API key.

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

## Pricing

from $1.60 / 1,000 channels

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 Stats Tracker

Give it Twitch channels (logins or URLs), or ask for the **top games** or the **biggest live streams**, and get one clean row per item: **followers, live status, viewers and game** for a channel, **rank, viewers and followers** for a game, **viewers, title, game, language and start time** for a stream. **$2.00 per 1,000 channels, $0.50 per 1,000 games or streams**, no login, no API key.

Run it again — or put it on a daily schedule — and every channel and game row also tells you **what changed since the last run**: followers gained and **followers per day** for a channel, **rank change and viewer change** for a game. Twitch only shows you today's numbers; the history comes from your own runs.

### What you get

Every row has `type` (`channel`, `game`, `stream` or `error`) and `observedAt`.

**Channels** (`"mode": "channels"`)

| Field | What it is |
|---|---|
| `login`, `displayName`, `channelId`, `url` | the channel; `input` repeats what you typed for it |
| `followers` | exact follower count (Twitch does not round it) |
| `isLive`, `streamType`, `viewers`, `streamTitle`, `game`, `tags`, `streamStartedAt`, `uptimeMinutes` | the current broadcast; `null` when the channel is offline |
| `lastBroadcastAt`, `lastBroadcastTitle`, `lastBroadcastGame` | the most recent broadcast that started (also while offline) |
| `description`, `language`, `createdAt`, `isPartner`, `isAffiliate` | the channel bio (emails and phone numbers removed), its language setting, when it was created and its status |
| `previousFollowers`, `followersChange`, `followersPerDay`, `hoursSinceLastRun` | the change since your previous run (`null` on the first run) |
| `firstSeenAt`, `observations`, `growthNote` | when this Actor first read the channel, how many times, and a one-line explanation of the growth figures |

**Top games** (`"mode": "topGames"`)

| Field | What it is |
|---|---|
| `rank`, `name`, `gameId`, `url` | the game (category), in order of live viewers |
| `viewers`, `broadcasters` | people watching it right now, and channels streaming it |
| `followers`, `tags` | people following the category, and Twitch's content tags (FPS, IRL…) |
| `previousRank`, `rankChange`, `isNew` | rank at the previous run; places moved (**positive = moved up**); `true` when it was not in the previous top 100 |
| `previousViewers`, `viewersChange`, `followersChange`, `hoursSinceLastRun` | the change since your previous run |

**Live streams** (`"mode": "liveStreams"`)

| Field | What it is |
|---|---|
| `rank`, `viewers`, `streamId` | position by current viewers, the viewers, and Twitch's id for this broadcast |
| `login`, `displayName`, `url`, `followers` | the channel and its follower count |
| `title`, `game`, `language`, `tags`, `streamType` | what the stream says it is (title with emails and phone numbers removed); `streamType` is `live` for a normal broadcast and `rerun` for a replay |
| `startedAt`, `uptimeMinutes` | when it went live and for how long |

### Use it for

- **Streamer, sponsor and esports research** — compare channels by real momentum (followers per day), not just the total
- **Game and publisher tracking** — see which categories are climbing and which are falling, day by day
- **Market snapshots** — the biggest streams right now, by game or language, as data you can chart or store
- **Your own channels and clients** — a follower log with history you own, exportable to Sheets or your BI tool

### Input

```json
{ "mode": "channels", "channels": ["riotgames", "https://www.twitch.tv/twitchgaming"] }
```

```json
{ "mode": "topGames", "maxItems": 100 }
```

```json
{ "mode": "liveStreams", "game": "Just Chatting", "language": "JA", "maxItems": 30 }
```

Growth is remembered in a named key-value store in your Apify account (per channel, and one top-games list), so the second run of the same Actor already shows changes. Schedule it (Apify → Schedules) for a daily history.

### Pricing

**$2.00 per 1,000 channels** and **$0.50 per 1,000 games or streams**, plus $0.01 per run. Error rows (unknown channels, a list Twitch would not give, a note that nothing is live for your filter) are free. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing. Put all your channels in one run and you pay it once.

### Notes

- Public data only: what anyone sees on twitch.tv without signing in. No chat, viewer, follower or subscriber names are read, and emails and phone numbers are removed from bios and stream titles.
- Followers are exact, so `followersPerDay` is measured over the time since your previous run. If that was under an hour ago, `followersChange` is still given but `followersPerDay` stays `null`.
- Live fields (`viewers`, `streamTitle`, `game`, `tags`, `streamStartedAt`, `uptimeMinutes`) are filled only while the channel is live. `lastBroadcast*` is `null` for a channel that has never streamed. `tags` of a game can be empty.
- Twitch's limits without a login: the top-games list has **100** entries, and one list of streams has **30**. Asking for more than 30 streams makes the Actor merge several lists — the top 30 of each of the 100 biggest games (or, for one game, the top 30 per language) — and it stops once no unread game could hold a bigger stream. A small stream in a small category can still be missing, so past the first 30 the ranks are among the streams found. These runs take longer (about 40 seconds for 150 streams). With both a game and a language, one list is all Twitch gives: up to 30 streams. If the merging is cut short (Twitch busy), you get the streams read so far plus a free error row that says so.
- `language` filters on the language the broadcaster has set, so a stream's own `language` field can differ.
- Viewer numbers are the live count at the moment of the run and change every minute; schedule runs at the same time of day when you compare days.
- A login that does not exist on Twitch (a typo, or a channel that was renamed) comes back as a free error row. So do the cases where a list ends short for a known reason: channels beyond *Maximum items* (default 100), more games than Twitch lists (100), a game plus language list (30 at most), and a game or language with nobody live right now.
- `rank` of a game is its position by `viewers` at the moment of the run (Twitch's own list order lags the live counts a little, so the Actor sorts by the viewers column). Viewers and ranks near the bottom of the list move a few places between two runs minutes apart.

To track **YouTube** channels the same way (exact views per day, new videos, subscriber change), see [YouTube Channel Stats & Growth Tracker](https://apify.com/northbell/youtube-channel-growth-tracker). To find channels by keyword, see [YouTube Channel Finder](https://apify.com/northbell/youtube-channel-finder).

### For AI agents

`{"mode": "channels", "channels": ["riotgames"]}` returns one `channel` row with followers, live status and growth since the last run. `{"mode": "topGames", "maxItems": 10}` returns the 10 biggest games with `rankChange`. `{"mode": "liveStreams", "game": "Minecraft", "maxItems": 20}` returns the 20 biggest live streams of that game. Rows have `type`: `channel`, `game`, `stream` or `error`.

# Actor input Schema

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

Channels: one row per channel with followers and growth since your last run. Top games: the 100 biggest categories by viewers, with rank and viewer changes since your last run. Live streams: the biggest live streams, optionally of one game and/or one language.

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

Used when "What to read" is Channels. One channel per line: a Twitch login (riotgames) or a channel URL (https://www.twitch.tv/riotgames). Up to "Maximum items" channels are read per run.

## `game` (type: `string`):

Used when "What to read" is Live streams. Limit the streams to one game or category: its name (Just Chatting), its slug (just-chatting) or a twitch.tv/directory/category/… URL. Leave empty for the biggest streams across all of Twitch.

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

Used when "What to read" is Live streams. Only streams whose broadcaster has set this language. Leave empty for all languages.

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

How many rows to return: channels read, games listed (Twitch lists at most 100 without a login) or live streams. Without a login Twitch lists 30 streams per request, so asking for more than 30 streams makes the run slower (it merges several lists).

## Actor input object example

```json
{
  "mode": "channels",
  "channels": [
    "riotgames",
    "twitchgaming"
  ],
  "maxItems": 100
}
```

# Actor output Schema

## `channels` (type: `string`):

Followers, live status, viewers and followers per day since the last run.

## `games` (type: `string`):

The biggest categories by viewers with rank and viewer changes since the last run.

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

The biggest live streams with viewers, game, language and start time.

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

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/twitch-stats-tracker").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": [
        "riotgames",
        "twitchgaming",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/twitch-stats-tracker").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": [
    "riotgames",
    "twitchgaming"
  ]
}' |
apify call northbell/twitch-stats-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbell/twitch-stats-tracker"
        }
    }
}
```

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/fY2czJulMDyjJtSAS/builds/kMF20ui85NmWW7a7K/openapi.json