# Steam Game Intelligence — players, reviews, prices & owners (`istmobot/steam-game-intelligence`) Actor

Scrape Steam game data with no API key: live player counts, review scores and review texts, prices, discounts, SteamSpy owner estimates, tags, genres and store details for any game, plus top sellers, specials and search. Steam API alternative. Export JSON, CSV, Excel.

- **URL**: https://apify.com/istmobot/steam-game-intelligence.md
- **Developed by:** [Istmobot](https://apify.com/istmobot) (community)
- **Categories:** Other, Marketing
- **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.

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

## Steam Scraper & Steam API — player counts, reviews, prices & SteamSpy owners

Scrape **Steam game data** at scale: live **Steam player counts**, review scores, **Steam review texts**, prices and discounts, store details and **SteamSpy owner estimates** for any game. Use it as an unofficial **Steam API** for any list of app IDs, or pull Steam's **top sellers**, **specials** and **search results** in any store region.

### What is Steam Game Intelligence?

Steam Game Intelligence is a **Steam scraper** that gives you SteamDB-style data without SteamDB. It combines Steam's public JSON endpoints (store app details, the Steam Web API player count, store reviews and store search) with **SteamSpy** into one clean record per game.

- **No API key, no login, no browser** — it only reads public endpoints.
- **An easy alternative to the official Steam Web API**: instead of calling four Steam endpoints plus SteamSpy and merging the responses yourself, you get one flat item per game.
- **Four modes**: your own list of app IDs / URLs, global top sellers, specials (games on sale) or keyword search.
- **Any store region**: set `country` (us, gb, de, br, jp…) to get local prices and currency.
- **Polite by design**: store requests are throttled to Steam's rate limit, with automatic retry and backoff on HTTP 429 and server errors.
- Download your data as **JSON, CSV, Excel, HTML** or XML, or read it via the Apify API.

#### What data can I extract with Steam Game Intelligence?

| Field | Description |
|---|---|
| `currentPlayers` | Live concurrent player count right now (Steam Web API) |
| `reviewScoreDesc` | Steam review score label, e.g. "Very Positive" |
| `totalReviews` / `totalPositive` / `totalNegative` | Review counts across all languages and purchase types |
| `positiveRatio` | Share of positive reviews, 0–1 |
| `price` / `initialPrice` / `discountPercent` / `currency` | Current price, price before discount, discount %, currency for the chosen `country` |
| `isFree` | Free-to-play flag |
| `releaseDate` / `comingSoon` | Release date and whether the game is unreleased |
| `developers` / `publishers` | Studio and publisher names |
| `genres` / `categories` / `platforms` | Store genres, features (Single-player, Co-op…), platforms (windows, mac, linux) |
| `tags` | Top user tags (SteamSpy) |
| `ownersEstimate` / `ownersMin` / `ownersMax` | SteamSpy owner estimate range |
| `averagePlaytime` | SteamSpy average playtime in minutes (often `null`) |
| `metacriticScore` | Metacritic score shown on the store page |
| `headerImage` / `shortDescription` / `url` | Store header image, short description, store URL |
| `reviews` | Optional newest review texts: recommended or not, playtime at review, helpful votes, date, language |

### How can I use Steam data?

- **Game studios & publishers** — track competitors' player counts, review sentiment and pricing every day.
- **Market researchers & investors** — size genres with SteamSpy owner estimates, tags and review volume.
- **Deal sites & newsletters** — pull current Steam specials with prices and discounts in any region.
- **Content creators & analysts** — feed dashboards, Google Sheets or databases with fresh Steam stats.
- **Community managers** — export the newest Steam reviews for sentiment analysis.
- **Player-count trackers** — schedule the Actor hourly to build your own Steam player count history.

### How to scrape Steam data

1. Click **Try for free** on this Actor's page (you need a free Apify account).
2. Choose a **Mode**: specific apps, top sellers, search by keyword or specials.
3. Fill in app IDs / store URLs (or a search term), the store `country` and whether you want SteamSpy data and review texts.
4. Click **Start** and wait for the run to finish.
5. Download the dataset as JSON, CSV, Excel or HTML, or connect it to your tools via the API.

### How much does it cost to scrape Steam?

This Actor uses **pay-per-event** pricing — you only pay for games you actually get:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| `app-result` (one game in the dataset) | $0.002 per game = **$2 per 1,000 games** |

**Review texts and SteamSpy data are included at no extra charge.** Error items (invalid IDs, apps not found, failed fetches) are **never charged**.

Example: 1 run × 1,000 games = $0.005 + $2.00 = **$2.005**.

The Apify free plan includes **$5 of monthly credit**, which covers roughly **2,500 games** per month. You can set a **maximum cost per run**; once it is reached the Actor stops cleanly and keeps everything scraped so far.

### ⬇️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | `apps` | `topSellers` | `search` | `specials` | `apps` | What to scrape (required) |
| `appIds` | list of strings | — | `apps` mode: app IDs (`730`) or store.steampowered.com / steamcommunity.com / steamdb.info URLs |
| `searchTerm` | string | — | `search` mode: keyword, e.g. `roguelike` |
| `maxItems` | integer | `50` | Max apps in topSellers / search / specials mode (ignored in `apps` mode) |
| `country` | string | `us` | 2-letter store region for prices and currency |
| `includeSteamSpy` | boolean | `true` | Add owner estimates, average playtime and tags from SteamSpy |
| `includeReviews` | boolean | `false` | Add the newest review texts |
| `maxReviewsPerApp` | integer | `20` | Reviews per app when `includeReviews` is on |

```json
{
  "mode": "apps",
  "appIds": ["730", "570", "https://store.steampowered.com/app/1245620/ELDEN_RING/"],
  "country": "us",
  "includeSteamSpy": true,
  "includeReviews": true,
  "maxReviewsPerApp": 20
}
```

Top 100 sellers in Germany: `{ "mode": "topSellers", "maxItems": 100, "country": "de" }`

### ⬆️ Output

One item per game. The **Overview** table view in Apify Console shows image, name, players now, reviews, price, discount, owners and more at a glance.

```json
{
  "appId": 1245620,
  "name": "ELDEN RING",
  "type": "game",
  "url": "https://store.steampowered.com/app/1245620/",
  "isFree": false,
  "price": 59.99,
  "initialPrice": 59.99,
  "discountPercent": 0,
  "currency": "USD",
  "releaseDate": "Feb 24, 2022",
  "comingSoon": false,
  "developers": ["FromSoftware, Inc."],
  "publishers": ["FromSoftware, Inc.", "Bandai Namco Entertainment"],
  "genres": ["Action", "RPG"],
  "categories": ["Single-player", "Multi-player", "PvP", "Online Co-op", "Steam Achievements", "Full controller support"],
  "tags": ["Souls-like", "Open World", "Dark Fantasy", "RPG", "Difficult", "Action RPG"],
  "platforms": ["windows"],
  "metacriticScore": 94,
  "currentPlayers": 23130,
  "reviewScoreDesc": "Very Positive",
  "totalReviews": 1157026,
  "totalPositive": 1076557,
  "totalNegative": 80469,
  "positiveRatio": 0.93,
  "ownersEstimate": "20,000,000 .. 50,000,000",
  "ownersMin": 20000000,
  "ownersMax": 50000000,
  "averagePlaytime": null,
  "headerImage": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/1245620/.../header_alt_assets_3.jpg",
  "shortDescription": "THE CRITICALLY ACCLAIMED FANTASY ACTION RPG. Rise, Tarnished, and be guided by grace...",
  "reviews": [
    { "id": "236585976", "recommended": true, "text": "nice", "playtimeAtReview": 16586, "votesUp": 0, "createdAt": "2026-10-01T00:44:29.000Z", "language": "english" }
  ],
  "scrapedAt": "2026-10-01T01:36:19.569Z"
}
```

Notes on fields:

- `price` / `initialPrice` are in major units (59.99), `currency` follows `country`. Free games have `price: 0`, `currency: null`.
- `positiveRatio` is 0–1 (0.93 = 93 % positive) across all languages and purchase types.
- `tags`, `ownersEstimate`, `ownersMin`, `ownersMax`, `averagePlaytime` come from SteamSpy and are `null` with `includeSteamSpy: false`. `averagePlaytime` is in minutes and is `null` when SteamSpy has no playtime data (currently the case for most games).
- `playtimeAtReview` is in minutes. `reviews` is present only with `includeReviews: true`.

#### Error items

```json
{ "appId": 999999999, "url": "https://store.steampowered.com/app/999999999/", "errorType": "NOT_FOUND", "error": "No store data for app 999999999 in country \"us\"" }
```

`errorType` is `NOT_FOUND` (removed app or not sold in that region), `INVALID_APP_ID`, `FETCH_FAILED` or `LISTING_FAILED`. **Error items are never charged.**

### Integrations and API

**Apify API** — start a run and get results over HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/istmobot~steam-game-intelligence/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "topSellers", "maxItems": 20, "country": "us"}'
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("istmobot/steam-game-intelligence").call(run_input={
    "mode": "apps",
    "appIds": ["730", "570"],
    "country": "us",
})
for game in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(game["name"], game.get("currentPlayers"))
```

**Node.js** (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('istmobot/steam-game-intelligence').call({
    mode: 'search',
    searchTerm: 'roguelike',
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

- **Schedules** — run it hourly or daily to track Steam player counts, prices and reviews over time.
- **Webhooks** — get notified or trigger your own pipeline when a run finishes.
- **Make, Zapier, n8n** — send Steam data to Google Sheets, Airtable, Slack or a database without code.
- **AI agents** — use it from Claude, ChatGPT or any MCP client via the Apify MCP server (https://mcp.apify.com).

### FAQ

**Is it legal to scrape Steam?** This Actor only reads publicly available data from public endpoints, does not log in and does not collect personal data beyond what Steam publishes in public reviews (review texts carry no author names). Public data is generally fine to collect, but reviews are user-generated content — if you store or process it, be mindful of GDPR and similar privacy laws. You are responsible for using the data in line with applicable laws and the sites' terms; if unsure, consult a lawyer.

**Do I need a Steam API key?** No. Everything comes from public endpoints that need no key and no login.

**How fast is it?** Steam limits the store details endpoint to ~200 requests per 5 minutes, so the Actor fetches about one game every 1.5 s (≈40 games/minute). Player counts, reviews and SteamSpy run in parallel within that window.

**How accurate are SteamSpy owner estimates?** They are SteamSpy's estimated ranges, not official Valve numbers. Use them for relative comparisons and market sizing, not exact sales.

**Can I get historical player charts?** No — Steam only exposes the current player count. Schedule the Actor (e.g. hourly) and the dataset history becomes your chart.

**Can I schedule it?** Yes. Use Apify Schedules to run it on any cron interval (hourly, daily, weekly) and combine with webhooks or integrations to push the results wherever you need them.

**Why is a game missing in my region?** Some apps are not sold everywhere; you get a `NOT_FOUND` error item (free). Try another `country`.

**Does it include DLC, soundtracks, hardware?** In `apps` mode, anything with an app ID works. Listing modes return what Steam lists (bundles and packages are skipped); check the `type` field.

**Do I need proxies?** No. Requests are few, lightweight and rate-limited.

### Other Actors you might like

- [Metacritic Scraper](https://apify.com/istmobot/metacritic-scraper)
- [Earnings Call Transcripts Scraper](https://apify.com/istmobot/earnings-call-transcripts-scraper)
- [Zacks Rank Scraper](https://apify.com/istmobot/zacks-rank-scraper)
- [BoardGameGeek Scraper](https://apify.com/istmobot/boardgamegeek-scraper)

### Your feedback

Found a bug or want a new field? Open an issue in the **Issues** tab of this Actor — we read every one.

### Disclaimer

This is an **unofficial** tool. It is not affiliated with, endorsed by or sponsored by Valve Corporation, Steam or SteamSpy.

# Actor input Schema

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

"apps": the app IDs / store URLs you list. "topSellers": Steam's global top sellers. "search": store search by keyword. "specials": games currently on sale.

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

Used in "apps" mode. Numeric app IDs (730) or URLs from store.steampowered.com, steamcommunity.com or steamdb.info.

## `searchTerm` (type: `string`):

Used in "search" mode, e.g. "roguelike" or "portal".

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

How many apps to return in topSellers / search / specials mode. Ignored in "apps" mode.

## `country` (type: `string`):

2-letter country code for prices and currency, e.g. us, gb, de, br, jp.

## `includeSteamSpy` (type: `boolean`):

Add owner estimates, average playtime and user tags from SteamSpy. Adds ~1 s per app.

## `includeReviews` (type: `boolean`):

Add the newest user reviews (text, recommended, playtime, votes) to each app.

## `maxReviewsPerApp` (type: `integer`):

Number of newest reviews per app when review texts are included.

## Actor input object example

```json
{
  "mode": "apps",
  "appIds": [
    "730",
    "570",
    "https://store.steampowered.com/app/1245620/ELDEN_RING/"
  ],
  "searchTerm": "roguelike",
  "maxItems": 20,
  "country": "us",
  "includeSteamSpy": true,
  "includeReviews": false,
  "maxReviewsPerApp": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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": "apps",
    "appIds": [
        "730",
        "570",
        "https://store.steampowered.com/app/1245620/ELDEN_RING/"
    ],
    "searchTerm": "roguelike",
    "maxItems": 20,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("istmobot/steam-game-intelligence").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": "apps",
    "appIds": [
        "730",
        "570",
        "https://store.steampowered.com/app/1245620/ELDEN_RING/",
    ],
    "searchTerm": "roguelike",
    "maxItems": 20,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("istmobot/steam-game-intelligence").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": "apps",
  "appIds": [
    "730",
    "570",
    "https://store.steampowered.com/app/1245620/ELDEN_RING/"
  ],
  "searchTerm": "roguelike",
  "maxItems": 20,
  "country": "us"
}' |
apify call istmobot/steam-game-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,istmobot/steam-game-intelligence"
        }
    }
}
```

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/oD98b7y91UmhQDzJ9/builds/uNb4XI01qdsOgXnaJ/openapi.json