# TwitchTracker Analytics Scraper (`crawlerbros/twitchtracker-analytics-scraper`) Actor

Scrape TwitchTracker.com channel analytics, category/game stats, top-streamer and top-subscriber leaderboards, top-games rankings, per-language Twitch statistics, and site-wide Twitch statistics. No login, no cookies, no proxy required.

- **URL**: https://apify.com/crawlerbros/twitchtracker-analytics-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## TwitchTracker Analytics Scraper

Scrape **TwitchTracker.com** — the most popular independent Twitch analytics tracker. Look up any Twitch channel's rank, average/peak viewers, hours watched, followers gained and subscriber counts; get the same 30-day analytics for any game or category; browse the top-streamer and top-games leaderboards; or pull aggregate live/7-day statistics for any of 35 stream languages. No login, no cookies, no proxy required.

### What this actor does

- **Seven modes:** `channel`, `game`, `topStreamers`, `topGames`, `topSubscribers`, `language`, `siteStatistics`
- **Channel analytics:** rank, average/peak viewers, hours watched, followers gained (30 days), total followers, current/paid/gifted active subscribers, all-time high subscribers, partner/affiliate status
- **Game/category analytics:** average viewers, average channels, rank, hours watched — by name or numeric Twitch category ID
- **Leaderboards:** top streamers (8 sort orders, 35 language filters, personality/esports category filter), top games, and top subscribers (current or all-time peak), with pagination
- **Language stats:** live viewers, 7-day average viewers/channels, top live streams and top channels for any tracked language
- **Empty fields are omitted** — every field in the output is real data; nothing is ever a placeholder

### Output: per-channel (mode = `channel`)

- `channelName`, `displayName`
- `channelId` — TwitchTracker's internal channel ID
- `avatarUrl`, `bannerUrl`
- `language`, `createdAt` — Twitch account creation date
- `partnerStatus` — `Partner` or `Affiliate` (omitted if neither)
- `rank` — TwitchTracker's algorithmic rank based on the trailing 30 days
- `avgViewers`, `maxViewers`, `minutesStreamed`, `hoursStreamed`, `hoursWatched`
- `followersGained30d` — can be negative if unfollows outpaced new follows
- `followersTotal`
- `currentActiveSubs`, `paidActiveSubs`, `giftedActiveSubs`, `allTimeHighActiveSubs`
- `twitchUrl`, `sourceUrl`
- `recordType: "channel"`, `scrapedAt`

> Channels with no streaming activity in the last 30 days (e.g. retired streamers) will be missing the `rank`/`avgViewers`/`hoursWatched`/`followers*` fields — the record still includes every profile field (subs, language, avatar, etc.) that TwitchTracker can populate.

### Output: per-game (mode = `game`)

- `gameId` (when looked up by numeric ID) or `gameName` (when looked up by name)
- `avgViewers`, `avgChannels`, `rank`, `hoursWatched` — trailing 30 days
- `twitchCategoryUrl` — Twitch's own category directory page (only when the game was looked up by name)
- `sourceUrl`
- `recordType: "game"`, `scrapedAt`

### Output: per-streamer row (mode = `topStreamers`)

- `channelName`, `displayName`, `avatarUrl`
- `rank` — overall algorithmic rank; `sortPosition` — position within the requested sort order
- `avgViewers`, `timeStreamedHours`, `allTimePeakViewers`, `hoursWatched`, `followersGained30d`, `followersTotal`, `totalViews`
- `currentGame`, `liveViewers`, `gameSharePercent`, `viewershipSharePercent` — only present when `sortBy: live` (a real-time snapshot instead of the 30-day leaderboard)
- `leaderboardSort`, `languageFilter`, `categoryFilter` — the filters actually applied to this row
- `twitchUrl`, `sourceUrl`
- `recordType: "streamer"`, `scrapedAt`

### Output: per-game row (mode = `topGames`)

- `rank`, `gameId` (omitted for Twitch's uncategorized "Variety" bucket), `gameName`, `boxArtUrl`
- `avgViewers`, `weeklyChangePercent` (signed — negative means viewership dropped), `twitchSharePercent`
- `twitchCategoryUrl`, `sourceUrl`
- `recordType: "game"`, `scrapedAt`

### Output: per-channel row (mode = `topSubscribers`)

- `rank`, `channelName`, `displayName`, `avatarUrl`
- `currentActiveSubs`, `paidActiveSubs`, `primeActiveSubs`, `giftedActiveSubs`, `tier1ActiveSubs`, `tier2ActiveSubs`, `tier3ActiveSubs` — only when `subSortBy: current` (the default)
- `allTimePeakActiveSubs`, `achievementDate`, `currentActiveSubs`, `isActiveStreamer` — only when `subSortBy: allTime`
- `subscriberSort`, `languageFilter` (current only — TwitchTracker doesn't support combining the all-time leaderboard with a language filter)
- `twitchUrl`, `sourceUrl`
- `recordType: "subscriberLeaderboard"`, `scrapedAt`

### Output: per-language aggregate (mode = `language`)

- `language`
- `liveViewers`, `avgViewers7d`, `liveChannels`, `avgChannels7d`
- `topLiveStreams[]` — up to 10 entries: `channelName`, `displayName`, `avatarUrl`, `viewers`, `twitchUrl`
- `topChannelsByViewership[]` — up to 10 entries with the same shape
- `sourceUrl`
- `recordType: "language"`, `scrapedAt`

### Output: site-wide statistics (mode = `siteStatistics`)

One record per run, shaped by the requested `statCategory`:

- `statCategory` — the category that was fetched
- `overview`: `liveViewers`, `avgViewers7d`, `liveChannels`, `avgChannels7d`
- `viewers`: `liveViewers`, `avgViewers24h`, `avgViewers7d`, `allTimePeakViewers`, `allTimePeakViewersDate`
- `channels`: `liveChannels`, `avgChannels24h`, `avgChannels7d`, `allTimePeakChannels`, `allTimePeakChannelsDate`
- `games`: `liveGames`, `gamesStreamedPastWeek`
- `activeStreamers`: `totalStreamersThisMonth`, `allTimePeakStreamers`, `allTimePeakStreamersDate`, `avgActiveStreamersDaily`, `activeStreamersYesterday`
- `streamTime`: `totalStreamHoursThisMonth`, `allTimePeakStreamHours`, `allTimePeakStreamHoursDate`, `avgStreamHoursDaily`, `streamHoursYesterday`
- `watchTime`: `totalWatchHoursThisMonth`, `allTimePeakWatchHours`, `allTimePeakWatchHoursDate`, `avgWatchHoursDaily`, `watchHoursYesterday`
- `sourceUrl`
- `recordType: "siteStatistics"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `topStreamers` | `topStreamers` / `channel` / `game` / `topGames` / `topSubscribers` / `language` / `siteStatistics` |
| `channelNames` | array | – | Twitch usernames to look up (mode=channel) |
| `gameNames` | array | – | Game/category names or numeric Twitch category IDs (mode=game) |
| `sortBy` | select | `ranking` | Leaderboard sort (mode=topStreamers): `ranking`, `viewership`, `peak-viewers`, `hours-watched`, `followers-growth`, `most-followers`, `most-views`, `live` |
| `subSortBy` | select | `current` | Subscriber leaderboard type (mode=topSubscribers): `current` or `allTime` |
| `language` | select | `any` | Optional filter for mode=topStreamers/topSubscribers (current only); the language to fetch for mode=language (35 languages) |
| `category` | select | `any` | Optional channel category filter for mode=topStreamers: `personality` or `esports` |
| `statCategory` | select | `overview` | Site-wide statistics page (mode=siteStatistics): `overview`, `viewers`, `channels`, `games`, `activeStreamers`, `streamTime`, `watchTime` |
| `maxItems` | int | `20` | Hard cap on emitted records (1–500) |

#### Example: look up specific channels

```json
{
  "mode": "channel",
  "channelNames": ["kaicenat", "shroud", "hasanabi"]
}
```

#### Example: look up a game by name or ID

```json
{
  "mode": "game",
  "gameNames": ["Just Chatting", "League of Legends", "509658"]
}
```

#### Example: top German esports streamers by peak viewers

```json
{
  "mode": "topStreamers",
  "sortBy": "peak-viewers",
  "language": "german",
  "category": "esports",
  "maxItems": 50
}
```

#### Example: top games leaderboard

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

#### Example: top subscriber counts (current)

```json
{
  "mode": "topSubscribers",
  "subSortBy": "current",
  "maxItems": 50
}
```

#### Example: all-time peak subscriber counts

```json
{
  "mode": "topSubscribers",
  "subSortBy": "allTime",
  "maxItems": 50
}
```

#### Example: Korean-language Twitch statistics

```json
{
  "mode": "language",
  "language": "korean"
}
```

#### Example: site-wide watch-time statistics

```json
{
  "mode": "siteStatistics",
  "statCategory": "watchTime"
}
```

### Use cases

- **Influencer/creator analytics** — benchmark a streamer's viewership, growth, and subscriber trends
- **Esports & agency scouting** — find rising or top-ranked streamers by category and language
- **Market research** — track which games are gaining or losing Twitch viewership week over week
- **Localization strategy** — see which languages/regions have the most active Twitch audiences
- **Competitive intelligence** — compare average viewers, peak viewers, and follower growth across channels
- **Content calendars** — identify the best-performing games and streamers to inform sponsorship decisions

### Limitations

TwitchTracker's `/clips` (curated clip gallery) page renders its grid entirely from a client-side data blob (there's no server-rendered clip data or documented API for it), so it isn't exposed as a mode. The `/statistics/*` pages' historical trend charts are similarly client-rendered from a proprietary compressed blob and aren't exposed, but their static top-line current/24h/7-day/all-time figures are — via `mode: siteStatistics`. Every other tabular/JSON-backed surface on the site (channel profiles, game/category summaries, the 8 top-streamer leaderboard sorts, top games, current + all-time subscriber leaderboards, per-language aggregate stats, and site-wide statistics) is fully supported.

### FAQ

**What is TwitchTracker?** An independent, long-running analytics site that tracks Twitch channel and game statistics going back years, including historical rank, viewership, and subscriber trends not exposed by Twitch itself.

**Why do some channels have fewer fields than others?** TwitchTracker's 30-day analytics (rank, average/peak viewers, hours watched, followers gained) require the channel to have streamed within the last 30 days. Inactive channels still return every profile field TwitchTracker can populate (subscriber counts, language, avatar, account creation date, partner status).

**Why can `followersGained30d` be negative?** It's the net follower change over the trailing 30 days — new followers minus unfollows. Large or declining channels can show a negative number.

**What's the difference between `rank` and `sortPosition` on a `topStreamers` row?** `rank` is TwitchTracker's overall algorithmic rank across all of Twitch. `sortPosition` is the row's position within whichever leaderboard you requested via `sortBy` — these differ whenever `sortBy` isn't `ranking`.

**Why do `sortBy: live` rows look different from the others?** The `live` leaderboard is a real-time snapshot of who's currently streaming (current game, live viewer count, share of that game's viewers), not a 30-day aggregate — so fields like `hoursWatched` and `followersGained30d` don't apply and are omitted.

**Can I combine `language` and `category` filters on the leaderboard?** Yes for most sort orders. The `live` sort order only supports one filter at a time; if both are supplied, the actor automatically drops the category filter and reports which filter was actually applied on each record via `languageFilter`/`categoryFilter`.

**Do I need to know a game's numeric Twitch category ID?** No — `gameNames` accepts either the human-readable name (e.g. `Just Chatting`) or the numeric ID (e.g. `509658`); both resolve to the same analytics.

**How fresh is the data?** TwitchTracker recalculates its 30-day and 7-day rolling statistics daily; leaderboards and live snapshots reflect current data at the time of the run.

**What's the difference between `subSortBy: current` and `allTime` on `topSubscribers`?** `current` ranks channels by their active subscriber count right now (with a breakdown of paid/prime/gifted/tier splits); `allTime` ranks channels by the highest active-subscriber count they've ever reached, along with the month that peak happened and whether the channel is still active. TwitchTracker doesn't support combining `allTime` with a `language` filter, so `language` is ignored (and never included on the record) when `subSortBy: allTime`.

**Is a proxy or login required?** No. The actor reads TwitchTracker's publicly accessible pages and JSON endpoints directly — no authentication, cookies, or paid proxy needed.

**Is this affiliated with TwitchTracker or Twitch?** No, this is a third-party actor using TwitchTracker's publicly accessible pages and endpoints. It is not affiliated with, endorsed by, or sponsored by TwitchTracker or Twitch.

**What does `mode: siteStatistics` give me that `topStreamers`/`topGames` don't?** It's Twitch-wide, not per-channel or per-game: total live viewers/channels right now, 24-hour/7-day averages, all-time peaks (with the date/month they happened), and month-to-date totals for streamers, stream hours, and watch hours. Use it to track overall platform trends rather than any single channel or game.

# Actor input Schema

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

What to fetch.

## `channelNames` (type: `array`):

One or more Twitch usernames to look up, e.g. `kaicenat`, `shroud`, `hasanabi`.

## `gameNames` (type: `array`):

Game/category names (e.g. `Just Chatting`, `League of Legends`) or numeric Twitch category IDs (e.g. `509658`).

## `sortBy` (type: `string`):

Which leaderboard to browse. Only used when mode=topStreamers.

## `subSortBy` (type: `string`):

Which subscribers leaderboard to browse. Only used when mode=topSubscribers.

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

For mode=topStreamers/topSubscribers (subSortBy=current only): optional language filter. For mode=language: the language to fetch aggregate statistics for (required).

## `category` (type: `string`):

Optionally restrict the leaderboard to a channel category. Only used when mode=topStreamers.

## `statCategory` (type: `string`):

Which site-wide Twitch statistics page to fetch. Only used when mode=siteStatistics.

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

Hard cap on emitted records. For mode=channel/game this caps the number of resolved lookups; for mode=topStreamers/topGames/topSubscribers/language it caps leaderboard rows.

## Actor input object example

```json
{
  "mode": "topStreamers",
  "channelNames": [
    "kaicenat"
  ],
  "gameNames": [
    "Just Chatting"
  ],
  "sortBy": "ranking",
  "subSortBy": "current",
  "language": "english",
  "category": "any",
  "statCategory": "overview",
  "maxItems": 10
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped TwitchTracker records.

# 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": "topStreamers",
    "channelNames": [
        "kaicenat"
    ],
    "gameNames": [
        "Just Chatting"
    ],
    "sortBy": "ranking",
    "subSortBy": "current",
    "language": "english",
    "category": "any",
    "statCategory": "overview",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/twitchtracker-analytics-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": "topStreamers",
    "channelNames": ["kaicenat"],
    "gameNames": ["Just Chatting"],
    "sortBy": "ranking",
    "subSortBy": "current",
    "language": "english",
    "category": "any",
    "statCategory": "overview",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/twitchtracker-analytics-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": "topStreamers",
  "channelNames": [
    "kaicenat"
  ],
  "gameNames": [
    "Just Chatting"
  ],
  "sortBy": "ranking",
  "subSortBy": "current",
  "language": "english",
  "category": "any",
  "statCategory": "overview",
  "maxItems": 10
}' |
apify call crawlerbros/twitchtracker-analytics-scraper --silent --output-dataset

```

## MCP server setup

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