# SteamCharts Player-Count Scraper (`crawlerbros/steamcharts-player-count-scraper`) Actor

Scrape steamcharts.com for real-time Steam concurrent player counts, top-games rankings, 24-hour trending gainers, game search, and full historical player-count history back to 2012.

- **URL**: https://apify.com/crawlerbros/steamcharts-player-count-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **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

## SteamCharts Player-Count Scraper

Track real-time Steam concurrent-player counts, sourced from [steamcharts.com](https://steamcharts.com) — the go-to independent tracker of "who's playing what" on Steam. Pull the full top-games leaderboard, the day's biggest 24-hour trending gainers, all-time peak-player records, a text search across every tracked title, or the complete player-count history for any specific game back to when SteamCharts began tracking it in mid-2012.

No login, no API key, no cookies required.

### What this actor does

- **`topGames`** (default) — the full ranked leaderboard of every game SteamCharts tracks, sorted by current concurrent players, paginated automatically until your `maxItems` cap is reached.
- **`trending`** — the day's top 24-hour concurrent-player gainers (biggest percentage jumps). SteamCharts surfaces a short, fixed-size list here (typically under 10 games) — `maxItems` is a ceiling, not a guarantee.
- **`search`** — text search across every tracked game by name/title.
- **`gameDetails`** — full detail + player-count history for one or more explicit Steam App IDs: current players, 24-hour peak, all-time peak, a month-by-month summary table, and the complete historical average-player chart data (monthly resolution for older periods, refining to daily/hourly for the most recent months).
- **`topRecords`** — the all-time leaderboard of highest concurrent-player peaks ever recorded on Steam, with the date each record was set. SteamCharts surfaces a short, fixed-size list here (typically around 10-20 games) — `maxItems` is a ceiling, not a guarantee.

### Output per record

#### `topGames` mode

| Field | Description |
|---|---|
| `rank` | Current leaderboard position |
| `appId` | Steam App ID |
| `name` | Game title |
| `currentPlayers` | Current concurrent players |
| `peakPlayers30d` | Peak concurrent players in the last 30 days |
| `hoursPlayed30d` | Total hours played across all players in the last 30 days |
| `imageUrl` | Game header image |
| `sourceUrl` | SteamCharts page for this game |

#### `trending` mode

| Field | Description |
|---|---|
| `appId` | Steam App ID |
| `name` | Game title |
| `gainPercent24h` | Percent change in concurrent players over the last 24 hours |
| `currentPlayers` | Current concurrent players |
| `imageUrl` | Game header image |
| `sourceUrl` | SteamCharts page for this game |

#### `search` mode

| Field | Description |
|---|---|
| `appId` | Steam App ID |
| `name` | Game title |
| `currentPlayers` | Current concurrent players |
| `avgPlayers30d` | Average concurrent players over the last 30 days |
| `gain30d` | Absolute change in average players over 30 days |
| `gainPercent30d` | Percent change in average players over 30 days |
| `imageUrl` | Game header image |
| `sourceUrl` | SteamCharts page for this game |

#### `gameDetails` mode

| Field | Description |
|---|---|
| `appId` | Steam App ID |
| `name` | Game title |
| `currentPlayers` | Current concurrent players |
| `currentPlayersAsOf` | UTC timestamp SteamCharts last refreshed the current-player count |
| `peak24h` | Peak concurrent players in the last 24 hours |
| `peakAllTime` | Highest concurrent-player count ever recorded for this game |
| `storeUrl` | Steam store page |
| `communityHubUrl` | Steam Community hub page |
| `imageUrl` | Game header image |
| `sourceUrl` | SteamCharts page for this game |
| `monthlyHistory[]` | Month-by-month summary: `month`, `avgPlayers`, `gain`, `gainPercent`, `peakPlayers` |
| `historicalChartData[]` | Complete average-player timeseries: `month` (`YYYY-MM-DD`), `timestamp` (full UTC instant, `YYYY-MM-DDTHH:MM:SSZ`), `avgPlayers` — going back to when SteamCharts began tracking the game (mid-2012 for the oldest titles). Resolution isn't uniformly monthly: older periods have one point per calendar month, while the most recent 1-3 months progressively refine to daily or even hourly data points as SteamCharts accumulates fresh samples, so you may see several entries sharing the same `month` date with different `timestamp`/`avgPlayers` values — that's expected, not duplicate/bad data. Use `timestamp` (not `month`) to tell same-day points apart or sort them chronologically |

#### `topRecords` mode

| Field | Description |
|---|---|
| `appId` | Steam App ID |
| `name` | Game title |
| `allTimePeakPlayers` | Highest concurrent-player count ever recorded |
| `allTimePeakDate` | Date/time the record was set (ISO 8601, UTC) |
| `imageUrl` | Game header image |
| `sourceUrl` | SteamCharts page for this game |

Every record also includes `recordType` and `scrapedAt` (UTC timestamp). Fields that can't be populated for a given record are simply omitted — you'll never see `null`, empty strings, or placeholder values.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `topGames` | `topGames` / `trending` / `search` / `gameDetails` / `topRecords` |
| `searchQuery` | string | `counter-strike` | Game name to search for (mode=`search`) |
| `appIds` | array | `["730"]` | Steam App IDs to fetch (mode=`gameDetails`) |
| `includeFullHistory` | boolean | `true` | Include the complete `historicalChartData[]` (mode=`gameDetails`); disable for a lighter response |
| `minCurrentPlayers` | integer | – | Drop games below this concurrent-player count (modes `topGames`/`trending`/`search`) |
| `maxCurrentPlayers` | integer | – | Drop games above this concurrent-player count (modes `topGames`/`trending`/`search`) |
| `maxItems` | integer | `20` | Hard cap on records emitted (1–1000) |

#### Example: top 50 most-played games right now

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

#### Example: today's biggest trending gainers

```json
{
  "mode": "trending"
}
```

#### Example: search for battle royale titles

```json
{
  "mode": "search",
  "searchQuery": "battlegrounds"
}
```

#### Example: full history for Counter-Strike 2 and Dota 2

```json
{
  "mode": "gameDetails",
  "appIds": ["730", "570"],
  "includeFullHistory": true
}
```

#### Example: mid-size games only (10k–100k concurrent players)

```json
{
  "mode": "topGames",
  "minCurrentPlayers": 10000,
  "maxCurrentPlayers": 100000,
  "maxItems": 100
}
```

### Use cases

- **Market research** — track which games are gaining or losing player share over time
- **Esports & gaming media** — surface trending titles and breakout hits for coverage
- **Game developer competitive intelligence** — benchmark your game's concurrent players against competitors in the same genre
- **Investment / publisher analysis** — monitor engagement trends for publicly traded gaming companies' titles
- **Historical research** — pull a decade-plus of monthly player-count history for any Steam game
- **Dashboards & alerts** — feed live player counts into a BI tool or Slack/Discord bot

### FAQ

**What's SteamCharts?** An independent, community-run tracker of Steam's concurrent player counts, updated continuously by polling Steam's public player-count API. It's been running since 2012 and covers every game with any meaningful player base. See [steamcharts.com/about](https://steamcharts.com/about).

**How is this different from the official Steam Store API?** SteamCharts adds historical trending, ranking, and month-over-month analysis on top of raw concurrent-player numbers — data the Steam Store API doesn't expose.

**How fresh is the data?** SteamCharts polls Steam continuously; current-player figures are typically only minutes old.

**Why do some games have no `historicalChartData`?** Very recently released or very low-traffic games may not have accumulated enough tracked months yet. `monthlyHistory` (the on-page summary table) usually still has entries.

**Why does `historicalChartData` show several entries for the same recent date with different `avgPlayers` values?** SteamCharts' underlying chart feed only settles into one data point per calendar month for periods further in the past — the most recent 1-3 months are still being sampled at daily or hourly resolution as new data arrives, so you'll see multiple same-`month` entries with slightly different values until that month rolls over and consolidates. Each entry also carries a full-precision `timestamp` so you can tell them apart and sort them chronologically — this is expected source behavior, not duplicated or bad data.

**What does `gain30d` / `gainPercent30d` mean in `search` mode?** The change in *average* daily concurrent players between the current 30-day window and the prior 30-day window — negative values mean a declining player base.

**Does `search` require an exact title match?** No — it's a partial, case-insensitive text match against tracked game names, resolved by SteamCharts' own search index. Match behavior isn't purely based on query length: some very short queries return results while some longer ones return none, depending on how SteamCharts indexes that term. If you get zero results, try a different or more complete word from the title.

**What's the difference between `peak24h`/`peakAllTime` (gameDetails) and `allTimePeakPlayers` (topRecords)?** They're the same underlying metric — `topRecords` surfaces only the games that currently hold a top-20 all-time-peak ranking across all of Steam, while `gameDetails` gives you the all-time peak for any specific game you look up.

**Can I look up a game by name instead of App ID for `gameDetails`?** Not directly — run `search` first to find the App ID, then pass it to `gameDetails`. This keeps ID lookups exact and avoids ambiguous name matches.

**Is this affiliated with SteamCharts or Valve/Steam?** No, this is a third-party actor using SteamCharts' public website data. It is not affiliated with, endorsed by, or sponsored by SteamCharts, Valve, or Steam.

# Actor input Schema

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

What to fetch from SteamCharts.

## `searchQuery` (type: `string`):

Game name or partial title to search for, e.g. `counter-strike`. Matching is decided by SteamCharts' own search index, not a fixed character count — some short queries return matches while some longer ones don't. Try a more distinctive or complete word if you get zero results.

## `appIds` (type: `array`):

One or more numeric Steam App IDs to fetch full details + history for, e.g. `730` (Counter-Strike 2), `570` (Dota 2). Find an App ID in a game's Steam store URL: `store.steampowered.com/app/{appId}/`.

## `includeFullHistory` (type: `boolean`):

Fetch the complete average-player history back to when SteamCharts began tracking the game (mid-2012 for the oldest titles) — monthly resolution for older periods, refining to daily/hourly for the most recent months. Disable for a lighter response with only the monthly summary table.

## `minCurrentPlayers` (type: `integer`):

Drop games with fewer current concurrent players than this (modes: topGames, trending, search).

## `maxCurrentPlayers` (type: `integer`):

Drop games with more current concurrent players than this (modes: topGames, trending, search).

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

Hard cap on the number of records emitted.

## Actor input object example

```json
{
  "mode": "topGames",
  "searchQuery": "counter-strike",
  "appIds": [
    "730"
  ],
  "includeFullHistory": true,
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped SteamCharts 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": "topGames",
    "searchQuery": "counter-strike",
    "appIds": [
        "730"
    ],
    "includeFullHistory": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/steamcharts-player-count-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": "topGames",
    "searchQuery": "counter-strike",
    "appIds": ["730"],
    "includeFullHistory": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/steamcharts-player-count-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 '{
  "mode": "topGames",
  "searchQuery": "counter-strike",
  "appIds": [
    "730"
  ],
  "includeFullHistory": true,
  "maxItems": 20
}' |
apify call crawlerbros/steamcharts-player-count-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1LBdFQcu6BcmgFfog/builds/y9dJ2woQA2zgb6aOH/openapi.json