# 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Game Stats",
        "description": "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.",
        "version": "0.1",
        "x-build-id": "PXYPF51qxdFOxb4nA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/straightforward_hydra~steam-game-stats/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-straightforward_hydra-steam-game-stats",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/straightforward_hydra~steam-game-stats/runs": {
            "post": {
                "operationId": "runs-sync-straightforward_hydra-steam-game-stats",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/straightforward_hydra~steam-game-stats/run-sync": {
            "post": {
                "operationId": "run-sync-straightforward_hydra-steam-game-stats",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "appIds": {
                        "title": "Steam app IDs",
                        "type": "array",
                        "description": "Steam app IDs, e.g. 730 (Counter-Strike 2), 1245620 (Elden Ring). Find it in the store URL: store.steampowered.com/app/<APPID>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gameNames": {
                        "title": "Game names (resolved automatically)",
                        "type": "array",
                        "description": "Game names to look up instead of IDs, e.g. \"Elden Ring\". The top matching game is used. Merged with the App IDs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topList": {
                        "title": "Top-games list (optional)",
                        "enum": [
                            "none",
                            "top100in2weeks",
                            "top100forever",
                            "top100owned"
                        ],
                        "type": "string",
                        "description": "Instead of (or in addition to) specific games, pull a ranked list of top games.",
                        "default": "none"
                    },
                    "topListLimit": {
                        "title": "Top-list size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many games to return from the top list (max 100).",
                        "default": 100
                    },
                    "includeLivePlayers": {
                        "title": "Include live player count",
                        "type": "boolean",
                        "description": "Add each game's current live concurrent player count from Steam. Adds one fast request per game.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after this many games in total. Leave empty for no limit."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
