# Steam Game Stats (`straightforward_hydra/steam-game-stats`) Actor

Owners, ratings, playtime, price and live concurrent players for any Steam game, by app ID, name or top-games list. Official SteamSpy + Steam APIs, no key needed.

- **URL**: https://apify.com/straightforward\_hydra/steam-game-stats.md
- **Developed by:** [Dev D](https://apify.com/straightforward_hydra) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 games

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/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

## Steam Game Stats 🎮📊

**Get owners, ratings, playtime, price and live concurrent players for any Steam game — by app ID, game name, or a top-games list. Official SteamSpy + Steam APIs, no key required.**

This Actor pulls hard numbers for Steam games: estimated **owners**, positive/negative review counts and score, average and median **playtime**, current and initial **price**, peak concurrent players, and each game's **live player count right now**. Perfect for game developers, publishers, investors and market researchers sizing up a game or a whole genre.

> Uses the public SteamSpy API and Steam's public player-count endpoint — no key, no login, no browser.

***

### What you can do with it

- 📊 **Size up a game** — owners, review score, playtime and revenue signals in one row.
- 🕵️ **Competitor & market research** — compare a list of games or pull the top 100.
- 💹 **Investor / publisher due diligence** — ownership and engagement estimates.
- 🔥 **Track live players** — current concurrent players for any game, on a schedule.
- 🎯 **Pair with review data** — combine with a reviews scraper for full player intelligence.

### Features

- ✅ **No API key** — official public endpoints, works out of the box.
- ✅ **By app ID or game name** — pass IDs, or let it resolve names.
- ✅ **Top-games lists** — top 100 by 2-week players, all-time peak, or owners.
- ✅ **Rich records** — owners range, review score %, playtime, price, discount, peak CCU, live players, tags.
- ✅ **Low-maintenance** — stable official APIs, polite rate limiting built in.

***

### Finding a game's app ID

The **app ID** is the number in the Steam store URL:
`store.steampowered.com/app/`**`1245620`**`/ELDEN_RING` → app ID is `1245620`.
Or just pass the game **name** and the Actor resolves it.

### Input

| Field | Description |
|---|---|
| **Steam app IDs** | Numeric app IDs, e.g. `730`, `1245620`. |
| **Game names** | Names to resolve automatically, e.g. `Elden Ring`. |
| **Top-games list** | Optional: top 100 by 2-week players, all-time peak, or owners. |
| **Top-list size** | How many from the list (max 100). |
| **Include live players** | Add current concurrent players per game. |
| **Max results** | Overall cap. |

#### Example — a competitor set

```json
{
  "gameNames": ["Elden Ring", "Baldur's Gate 3", "Cyberpunk 2077"],
  "includeLivePlayers": true
}
```

#### Example — the top 50 games by current players

```json
{
  "topList": "top100in2weeks",
  "topListLimit": 50
}
```

### Output

Each row is one game:

```json
{
  "app_id": "1245620",
  "name": "ELDEN RING",
  "developer": "FromSoftware Inc.",
  "publisher": "Bandai Namco",
  "genre": "Action, RPG",
  "languages": "English, French, …",
  "owners": "20,000,000 .. 50,000,000",
  "owners_min": 20000000,
  "owners_max": 50000000,
  "positive": 981540,
  "negative": 75137,
  "review_score_pct": 92.89,
  "userscore": 0,
  "peak_ccu_yesterday": 29529,
  "live_player_count": 20788,
  "price_usd": 59.99,
  "initial_price_usd": 59.99,
  "discount_pct": 0,
  "average_playtime_forever_min": 0,
  "average_playtime_2weeks_min": 0,
  "median_playtime_forever_min": 0,
  "median_playtime_2weeks_min": 0,
  "tags_top": "Souls-like, Difficult, RPG, Open World, …",
  "tags": { "Souls-like": 12345, "Difficult": 9876 }
}
```

### Run it on a schedule

Schedule the Actor to log ownership, price and live players over time, and connect a **Google Sheets / Slack / webhook** integration to build your own dashboard.

### Notes & limitations

- Uses the public SteamSpy API and Steam's public player-count endpoint — no key needed.
- **Owners** are SteamSpy estimates given as a range; playtime is in minutes.
- `peak_ccu_yesterday` is SteamSpy's peak concurrent from the previous day; `live_player_count` is the current concurrent players from Steam.
- Price is in USD; `0` price means free-to-play.
- This is **public, non-personal** game data.

***

#### Keywords

Steam stats, SteamSpy, Steam owners, Steam player count, concurrent players, game analytics, Steam scraper, game market research, Steam game data, video game data, Steam API, owners estimate, game sales estimate, playtime data, Steam charts, game intelligence, gaming market data, game revenue estimate, Steam price tracker, top Steam games.

# Actor input Schema

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

Steam app IDs, e.g. 730 (Counter-Strike 2), 1245620 (Elden Ring). Find it in the store URL: store.steampowered.com/app/<APPID>.

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

Game names to look up instead of IDs, e.g. "Elden Ring". The top matching game is used. Merged with the App IDs above.

## `topList` (type: `string`):

Instead of (or in addition to) specific games, pull a ranked list of top games.

## `topListLimit` (type: `integer`):

How many games to return from the top list (max 100).

## `includeLivePlayers` (type: `boolean`):

Add each game's current live concurrent player count from Steam. Adds one fast request per game.

## `maxResults` (type: `integer`):

Stop after this many games in total. Leave empty for no limit.

## Actor input object example

```json
{
  "appIds": [
    "1245620"
  ],
  "topList": "none",
  "topListLimit": 100,
  "includeLivePlayers": true
}
```

# 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": [
        "1245620"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("straightforward_hydra/steam-game-stats").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": ["1245620"] }

# Run the Actor and wait for it to finish
run = client.actor("straightforward_hydra/steam-game-stats").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 '{
  "appIds": [
    "1245620"
  ]
}' |
apify call straightforward_hydra/steam-game-stats --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=straightforward_hydra/steam-game-stats",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/MdhrVh4A2AcGdjmWw/builds/PXYPF51qxdFOxb4nA/openapi.json