# Steam Charts Scraper: Concurrent Players & History (`recordsdata/steam-charts-scraper`) Actor

Scrape Steam Charts: top games ranked by live concurrent players with 30-day peaks and hours played, per-game stats (now playing, 24h peak, all-time peak) and monthly history back to 2012. Export CSV, Excel, JSON. No login or API key. 25 games per page.

- **URL**: https://apify.com/recordsdata/steam-charts-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** Games, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3" alt="PunkRecordsData" width="100%" />
</p>

## 📈 Steam Charts Scraper: Concurrent Players, Peaks & Monthly History

> **Steam Charts Scraper is an Apify actor that exports player-count data from steamcharts.com as structured rows: the top Steam games ranked by concurrent players (25 per page, up to 40 pages), per-game stats (playing now, 24-hour peak, all-time peak) and one row per month of average and peak players back to 2012. No login or API key. Export CSV, Excel, JSON or XML. Pay per row, nothing for errors or empty results.**

Steam Charts Scraper turns the reference tracker for Steam concurrent players into datasets you can chart, join and monitor. In a test run on 2026-10-04, Counter-Strike 2 was rank 1 with a 30-day peak of 1,450,705 players and an all-time peak of 1,818,368.

### 🎮 What does Steam Charts Scraper do?

It reads three kinds of pages on steamcharts.com and writes one dataset row per record:

- **Top games** (`recordType: "top-game"`): rank, game name, Steam app ID, current concurrent players, 30-day peak and hours played in the last 30 days.
- **Per-game stats** (`recordType: "game-stats"`): players right now, 24-hour peak and all-time peak for any Steam app ID.
- **Monthly history** (`recordType: "monthly"`): one row per month with average players, absolute gain, percentage gain and monthly peak. Old titles go back to 2012, and the latest row is "Last 30 Days".

Every row also carries the Steam store link, the Steam Charts link and a `scrapedAt` timestamp, so you can join with price or review data.

### 📊 What data can I get from Steam Charts?

| Field | Record type | Meaning |
|---|---|---|
| `rank` | top-game | Position in the current ranking |
| `appId`, `name` | all | Steam app ID and game name |
| `currentPlayers` | top-game | Concurrent players now |
| `peakPlayers30d`, `hoursPlayed30d` | top-game | 30-day peak and hours played |
| `playingNow`, `peak24h`, `allTimePeak` | game-stats | Live, 24-hour and record peaks |
| `month`, `avgPlayers`, `gain`, `gainPercent`, `peakPlayers` | monthly | One month of history |
| `steamUrl`, `url`, `scrapedAt` | all | Store page, tracker page, timestamp |

### 🧪 Steam Charts Scraper output sample (real run)

This row comes from a real run on 2026-10-04 (input: top list page 1, app ID 730). Fields that do not apply to a record type are left out of the row instead of being filled with null.

```json
{
  "recordType": "game-stats",
  "appId": "730",
  "name": "Counter-Strike 2",
  "playingNow": 530797,
  "peak24h": 1182939,
  "allTimePeak": 1818368,
  "steamUrl": "https://store.steampowered.com/app/730/",
  "url": "https://steamcharts.com/app/730",
  "scrapedAt": "2026-10-04T05:04:56.555Z"
}
```

A monthly row from the same run:

```json
{
  "recordType": "monthly",
  "appId": "730",
  "name": "Counter-Strike 2",
  "month": "Last 30 Days",
  "avgPlayers": 806812.49,
  "gain": 1174.7,
  "gainPercent": "+0.15%",
  "peakPlayers": 1450705,
  "scrapedAt": "2026-10-04T05:04:56.575Z"
}
```

### 💰 How much does Steam Charts Scraper cost?

Pay per event, charged only for rows that are saved to the dataset. Prices on the Free plan tier (higher Apify plans pay less on game stats):

| Event | Price | You get |
|---|---|---|
| `top-game-record` | $0.010 per row ($10 per 1,000) | One ranked game |
| `game-stats-record` | $0.012 per row | One game with live, 24h and all-time peak |
| `monthly-record` | $0.010 per row ($10 per 1,000) | One month of history |

Error rows, "app not tracked" rows and empty results are never charged. The actor stops cleanly when your `maxTotalChargeUsd` or `maxItems` is reached. Free Apify users get a 10-row preview per run.

Example: top 100 games (4 pages) is 100 rows, about $1.00. Five years of monthly history for one game is the stats row plus 60 monthly rows, about $0.61.

### 🚀 How do I use Steam Charts Scraper?

1. Open the actor on Apify and click **Try for free**.
2. Choose how many top pages to walk (25 games each) and/or paste Steam app IDs such as `730` (Counter-Strike 2) or `570` (Dota 2). Full steamcharts.com URLs also work.
3. Click **Start**, then download the dataset as CSV, Excel, JSON or XML.

### ⚙️ Steam Charts Scraper input

| Field | Default | Description |
|---|---|---|
| `includeTopGames` | `true` | Scrape the top games list ranked by concurrent players |
| `maxTopPages` | `4` | Pages of the top list (25 games each, 1 to 40) |
| `appIds` | none | Steam app IDs or steamcharts.com URLs for per-game stats and history |
| `includeMonthlyHistory` | `true` | Add one row per month for each app ID |
| `maxMonthsPerGame` | `60` | Cap on monthly rows per game (60 is five years) |
| `maxItems` | unlimited (10 on Free) | Hard cap on total rows delivered and charged |

Example input:

```json
{
  "includeTopGames": true,
  "maxTopPages": 2,
  "appIds": ["730", "570"],
  "includeMonthlyHistory": true,
  "maxMonthsPerGame": 24,
  "maxItems": 200
}
```

### 📦 Steam Charts Scraper output

Rows land in the default dataset. The Overview view shows the key columns per record type; the full dataset has every field. Rows are de-duplicated before they are charged.

### ⚖️ How does it compare with other Steam Charts scrapers?

Measured from the public Apify Store listings on 2026-10-04:

| Actor | Price per 1,000 rows | Monthly history | Per-game 24h and all-time peaks |
|---|---|---|---|
| This actor | $10 to $12 | Yes, back to 2012 | Yes |
| crawlerbros/steamcharts-player-count-scraper | $5 plus $0.005 per start | Not stated | Not stated |
| bakos\_bence/steamcharts-players | about $2 plus $0.001 per start | Not stated | Not stated |
| ninhothedev/steam-charts-scraper | $0.50 plus $0.00005 per start | Not stated | Not stated |

We are not the cheapest per row. The extra price pays for three record types in one run (ranking, live stats, monthly time series), Steam store links for joins, and a top list that walks up to 40 pages. If you only need a single page of current player counts, a cheaper actor will do the job.

### 💼 What can I use Steam Charts data for?

- **Competitive benchmarking**: your game's monthly curve against three rivals in one dataset.
- **Investor research**: engagement trends behind a publisher's portfolio.
- **Live-ops measurement**: player lift after each patch or event.
- **Content and media**: "most played games right now" with citable numbers.
- **Esports and community teams**: track when a title crosses a new peak.

### 🔌 How do I run Steam Charts Scraper from the API?

```bash
curl -X POST "https://api.apify.com/v2/acts/RecordsData~steam-charts-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"includeTopGames": true, "maxTopPages": 1, "appIds": ["730"], "maxItems": 50}'
```

With the `apify-client` package for Node.js or Python, call `client.actor("RecordsData/steam-charts-scraper").call(runInput)` and read the dataset items. The actor also plugs into Make, Zapier, n8n, Airbyte, Google Sheets and Slack through Apify integrations, for daily top-list snapshots or alerts when a game hits a new peak. AI agents can call it through the Apify MCP server.

### 🛡️ Is it legal to scrape Steam Charts?

The actor reads public pages on steamcharts.com at a polite rate (about one request per 1.2 seconds) and collects factual player counts. It does not log in or bypass any access control. Check the site's terms for your use, and credit Steam Charts when you republish the numbers.

### ❓ Steam Charts Scraper FAQ

#### Where do I find a game's Steam app ID?

It is the number in the game's store URL, for example `730` in store.steampowered.com/app/730. Top-list rows include `appId`, ready to paste into `appIds`.

#### How far back does the monthly history go?

To the first month steamcharts.com tracks for that game, as early as 2012. Use `maxMonthsPerGame` to cap it.

#### What is the difference between the three peaks?

`playingNow` is live. `peak24h` is the highest in the last 24 hours. `allTimePeak` is the record since tracking began. The top list adds a 30-day peak.

#### Why did I get 0 results?

Either no input was selected (turn on `includeTopGames` or add `appIds`), or the app ID is not tracked on steamcharts.com. In both cases the run succeeds with a status message and costs nothing. If steamcharts.com blocks the request or changes its layout, the run fails instead of finishing empty.

#### Am I charged for failed or empty rows?

No. Only rows saved to the dataset are charged, and error rows are written without a charge event.

#### Can I try it for free?

Yes. Free Apify users get a 10-row preview per run; paid plans unlock full runs.

#### How many games can the top list return?

25 per page, up to 40 pages (1,000 games).

#### Is the data real time?

It matches what steamcharts.com shows at run time, and every row has a `scrapedAt` timestamp.

### 🔗 Want more Steam and game data?

- [Steam Scraper: Reviews, Achievements, News & Players](https://apify.com/RecordsData/steam-games-player-stats)
- [Steam Reviews Scraper](https://apify.com/RecordsData/steam-reviews-scraper)
- [Epic Games Store Scraper](https://apify.com/RecordsData/epic-games-store-scraper)

### 🛟 Support

Found a bug or missing field? Open the Issues tab on this actor's page, or write to contact.punkrecordsdata@gmail.com. Custom solutions are available on request.

Last updated: 2026-10-03

# Actor input Schema

## `includeTopGames` (type: `boolean`):

Scrape the top games ranked by current concurrent players (25 per page).

## `maxTopPages` (type: `integer`):

Pages of the top list to walk (25 games each).

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

Steam app IDs or steamcharts.com URLs to get per-game stats (playing now, 24h peak, all-time peak) and monthly player history, for example 730 for Counter-Strike 2 or 570 for Dota 2. Leave empty to scrape only the top games list.

## `includeMonthlyHistory` (type: `boolean`):

One row per month with average and peak players, back to the game's first tracked month.

## `maxMonthsPerGame` (type: `integer`):

Cap on monthly rows per game (60 = last 5 years).

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

Maximum rows to deliver and charge across all record types. Free users are limited to 10 rows (preview); paid users can set up to 1,000,000. Leave empty for no cap.

## Actor input object example

```json
{
  "includeTopGames": true,
  "maxTopPages": 4,
  "appIds": [
    "730"
  ],
  "includeMonthlyHistory": true,
  "maxMonthsPerGame": 60,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "appIds": [
        "730"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/steam-charts-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 = {
    "appIds": ["730"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/steam-charts-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 '{
  "appIds": [
    "730"
  ],
  "maxItems": 10
}' |
apify call recordsdata/steam-charts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/steam-charts-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/bsnZhLmTfdYm3eafa/builds/eoS04Ze9gny2ulNrm/openapi.json
