Steam Game Statistics Scraper

Export normalized Steam game statistics for supplied app IDs or public Steam Store URLs. Each record combines current game identity, release data, genres, supported platforms, recommendation counts, and aggregate Steam review statistics with source timestamps.

Use the Actor for a one-time game comparison or schedule recurring snapshots for market analysis. It does not collect individual review text, estimate unit sales, or reconstruct historical values.

What does Steam Game Statistics Scraper do?

The Actor looks up exact games instead of searching loosely by title. For every valid app ID it requests two public Steam JSON surfaces:

1. Steam app details for identity and catalog metadata.
2. Steam app review summary for aggregate review counts and score.

It then emits one flat, typed dataset record per available app. Duplicate app IDs are removed before requests are made.

The result is ready for JSON, CSV, Excel, database, and BI workflows. No Steam account, cookies, or API key are required.

Who is this Steam statistics data for?

• Game publishers benchmarking competing title portfolios.
• Market analysts collecting comparable review and catalog snapshots.
• Indie developers checking genre, platform, and reception signals.
• Investment researchers enriching known Steam app lists.
• Data teams maintaining a normalized game catalog.
• No-code users exporting current statistics to a spreadsheet.

This Actor works best when you already know the Steam app IDs or URLs you want to analyze.

Why use this Actor?

Steam exposes useful data across more than one response shape. This Actor joins those surfaces and normalizes their fields into one stable row.

Key advantages:

• Exact app-ID targeting avoids ambiguous title matches.
• App IDs and full Store URLs can be mixed in one run.
• Aggregate positive and negative review counts are returned together.
• The positive review percentage is calculated consistently.
• Country and metadata language are explicit inputs.
• Each source response has its own fetch timestamp and URL.
• Duplicate inputs are requested only once.
• The default dataset works directly with Apify integrations.

Unlike our Steam sale-price tracker, this Actor focuses on game metadata and reception statistics, not regional sale-price or discount observations.

What Steam game data is extracted?

Field group	Fields	Meaning
Identity	appId, name, appType, storeUrl	Canonical Steam app identity
Input context	sourceInput, country, language	Input and locale used for the lookup
Release	releaseDate, comingSoon, requiredAge	Current release and age metadata
Classification	genres, categories	Steam's localized labels
Platforms	platforms, controllerSupport	Supported desktop systems and controller label
Organizations	developers, publishers	Published developer and publisher names
Popularity	recommendationsTotal, achievementsTotal	Aggregate Store indicators when exposed
External score	metacriticScore, metacriticUrl	Optional Metacritic data exposed by Steam
Reviews	reviewScore, reviewScoreDescription	Steam aggregate score code and label
Review totals	totalReviews, positiveReviews, negativeReviews	Current all-language aggregate counts
Calculated	positiveReviewPercent	Positive reviews divided by total reviews
Links	website, imageUrl	Optional game website and Steam header image
Provenance	detailsSourceUrl, reviewsSourceUrl	Exact public JSON sources
Timestamps	detailsFetchedAt, reviewsFetchedAt, scrapedAt	UTC collection timestamps

Optional source fields are returned as null when Steam does not expose them. Arrays are empty when no values are present.

How to run the Actor

1. Open Steam Game Statistics Scraper in Apify Console.
2. Enter one or more numeric Steam app IDs, Steam Store app URLs, or both.
3. Keep US and english, or choose another supported country and Steam language.
4. Set the maximum number of unique games to save.
5. Click Start.
6. Open the default dataset and select JSON, CSV, Excel, XML, or RSS.

The prefilled IDs produce real records, so you can run the Actor immediately.

Input parameters

Steam app IDs

appIds is a list of numeric identifiers such as 730, 570, and 620. The input editor stores them as strings so large IDs remain exact. Up to 200 combined IDs and URLs are accepted.

Steam app URLs

steamUrls accepts public URLs shaped like:

https://store.steampowered.com/app/620/Portal_2/

Only the numeric app ID is needed from the URL. Query strings, fragments, and localized title slugs are allowed.

Country

country is a two-letter code such as US, GB, DE, or JP. Steam can hide an app in a particular country. An unavailable app is skipped with a warning and is not charged as an item.

Language

language is a Steam language name such as english, german, or spanish. It affects localized names, genre labels, categories, and release text. Review totals use all available review languages for comparable aggregates.

Maximum games

maxItems stops the run after the requested number of unique records. It must be from 1 to 200. The limit is applied after app-ID deduplication.

Example input

{
  "appIds": ["730", "570", "440"],
  "steamUrls": ["https://store.steampowered.com/app/620/Portal_2/"],
  "country": "US",
  "language": "english",
  "maxItems": 4
}

This produces at most four unique game-statistics rows.

Example output

The following shortened record comes from a real local lookup of app 730:

{
  "appId": 730,
  "name": "Counter-Strike 2",
  "appType": "game",
  "storeUrl": "https://store.steampowered.com/app/730/",
  "country": "US",
  "language": "english",
  "isFree": true,
  "developers": ["Valve"],
  "publishers": ["Valve"],
  "genres": ["Action", "Free To Play"],
  "platforms": ["Windows", "Linux"],
  "releaseDate": "Aug 21, 2012",
  "comingSoon": false,
  "reviewScore": 8,
  "reviewScoreDescription": "Very Positive",
  "totalReviews": 9855664,
  "positiveReviews": 8464639,
  "negativeReviews": 1391025,
  "positiveReviewPercent": 85.89,
  "detailsFetchedAt": "2026-09-13T20:27:54.879Z",
  "reviewsFetchedAt": "2026-09-13T20:27:55.138Z"
}

Counts change over time because Steam receives new reviews. Use the timestamps to identify when each snapshot was collected.

How much does it cost to export Steam game statistics?

The Actor uses pay-per-event pricing. A run has a $0.00005 start charge plus one item charge for each saved game record. On the FREE tier, the item rate is $0.002392 per game. Higher account tiers receive the tier rates shown in Apify Console.

Example FREE-tier costs:

Saved games	Estimated charge
1	$0.002442
10	$0.023970
100	$0.239250

Unavailable, malformed, duplicate, and unsaved games do not create an item charge. Apify displays the exact event total for every run.

Schedule recurring market snapshots

An individual run is a current snapshot, not a history database. To analyze movement over time:

1. Create an Apify Task with a stable list of app IDs.
2. Schedule it daily, weekly, or monthly.
3. Export each run dataset to your database or cloud storage.
4. Join records by appId and compare timestamped metrics.
5. Calculate changes in review totals, positive percentage, or Store metadata downstream.

The Actor does not claim that every field changes on every run. It also does not emit alerts or change-only events itself.

Export to spreadsheets and data pipelines

From the dataset page, download CSV or Excel for manual analysis. For automation, connect the finished run to:

• Google Sheets
• Make
• Zapier
• webhooks
• a custom Apify API client
• your warehouse ingestion job

Keep appId as the stable join key. Keep scrapedAt or the source-specific timestamps as the observation time.

Run with the Apify API

Replace YOUR_TOKEN with an Apify API token. Do not put tokens in source control.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~steam-game-statistics-export/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"appIds":["730","570"],"country":"US","language":"english","maxItems":2}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/steam-game-statistics-export').call({
  appIds: ['730', '570'],
  country: 'US',
  language: 'english',
  maxItems: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/steam-game-statistics-export').call(run_input={
    'appIds': ['730', '570'],
    'country': 'US',
    'language': 'english',
    'maxItems': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

For asynchronous pipelines, start the run first and fetch the dataset after its status becomes SUCCEEDED.

Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/steam-game-statistics-export"

Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use the equivalent HTTP MCP JSON configuration below. Add it through the client's MCP settings and provide your Apify authentication as required:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/steam-game-statistics-export"
    }
  }
}

Example prompts:

• “Export current Steam review totals for app IDs 730, 570, and 440.”
• “Fetch Portal 2 metadata from its Steam Store URL and summarize its platforms and review ratio.”
• “Build a timestamped four-game Valve portfolio snapshot for my weekly comparison.”

The assistant receives structured dataset rows rather than raw Store HTML.

Reliability and retries

Each Steam request has a 30-second timeout. The Actor retries timeouts, HTTP 429, and temporary server errors up to three attempts with backoff. It does not blindly retry malformed input or deterministic client errors.

Requests are intentionally processed conservatively. The Actor does not use an automatic residential proxy or browser fallback. An exhausted upstream request fails the run instead of silently returning misleading empty output.

Limits and known caveats

• Input is capped at 200 combined app IDs and URLs per run.
• Only exact app lookups are supported; title search is not supported.
• Region-blocked, removed, or unknown apps can be skipped.
• Review totals cover all review languages and all purchase types.
• Release dates are localized text from Steam, not normalized calendar dates.
• Recommendations and Metacritic fields may be absent for some games.
• recommendationsTotal and totalReviews are different Steam aggregates.
• The Actor does not return current concurrent players.
• The Actor does not return individual review bodies or authors.
• The Actor does not estimate owners, sales, or revenue.
• Steam can change public response shapes or rate limits.

Use a smaller Task cadence if your workflow repeatedly queries a large unchanged portfolio.

Errors and troubleshooting

A malformed ID or non-Steam URL fails the run with a clear validation message. This fail-closed behavior prevents partial datasets caused by typos.

If a valid app produces no row, check whether its Store page is available in the selected country. Try a country where you are authorized to access the public listing. Do not use the Actor to bypass geographic or legal restrictions.

If Steam temporarily rate-limits requests, the Actor performs bounded retries. After retry exhaustion, rerun later rather than launching many parallel copies.

Legality and responsible use

The Actor reads publicly accessible Steam Store responses without logging in. You are responsible for your use of the data and for complying with applicable laws, Steam terms, Apify terms, and your downstream platform's policies.

Do not use the output to identify individual reviewers because this Actor does not collect them. Do not attempt to evade access controls or geographic restrictions. Avoid excessive schedules and retain only the data your analysis needs.

This documentation is not legal advice.

FAQ

Does it require a Steam Web API key?

No. It uses anonymous public Steam Store JSON responses.

Can I enter game names instead of app IDs?

No. Exact app IDs and Steam app URLs avoid ambiguous name matching.

Does it scrape individual Steam reviews?

No. It exports aggregate score and positive, negative, and total review counts.

Are these historical statistics?

No. Every run is a current timestamped snapshot. Schedule Tasks and store datasets externally to create your own history.

Why do recommendation and review totals differ?

They are separate aggregates exposed by Steam and should not be treated as equivalent.

Why was a game skipped?

The app may be unknown, removed, or unavailable for the requested country. The run log includes its app ID and country.

Can I use another language?

Yes. Supply a Steam language name such as german or spanish. Review counts remain all-language aggregates.

Related Automation Lab Actors

• Steam Games Sale Prices Scraper tracks regional regular prices, discounts, and sale prices for searches or app IDs.

Use the sale tracker when price monitoring is the main job. Use this Actor when normalized metadata and aggregate review statistics are the main job.