# Steam Reviews and Store Data Scraper for Games (`bravona/steam-reviews-and-store-data`) Actor

Export Steam user reviews and store details (price, discounts, genres, review score) for any game, by App ID or search term, as JSON, CSV or Excel.

- **URL**: https://apify.com/bravona/steam-reviews-and-store-data.md
- **Developed by:** [Bravona](https://apify.com/bravona) (community)
- **Categories:** E-commerce, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 review returneds

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 Reviews and Store Data Scraper for Games

**Steam Reviews and Store Data Scraper** exports **Steam user reviews** and **store details** (price, discounts, genres, review score) for any game. Enter Steam **App IDs** or a **search term**, choose reviews, details or both, and download the results as JSON, CSV or Excel.

Unofficial tool. Not affiliated with, endorsed by, or sponsored by Valve Corporation or Steam.

### What does Steam Reviews and Store Data Scraper do?

- Collects user reviews for one or more games, found by App ID or by search term.
- Collects store details for each game: price, discounts, genres, categories, platforms and Metacritic score.
- Adds review summary stats for your chosen language and for all languages.
- Puts reviews and game details in one dataset, told apart by `itemType`.
- Never outputs reviewer Steam IDs, usernames, profile links or other author data.
- No login, no browser and no API key. Uses public Steam JSON endpoints.
- Runs on Apify: call it via API, schedule runs, export to JSON, CSV or Excel, and connect integrations.

### Who is it for?

**Indie developers**: read what players say about your game and your competitors. **Game publishers and market researchers**: compare prices, discounts, genres and review scores across a set of games. **Data scientists**: pull large sets of reviews for sentiment analysis.

### What data can you get from Steam?

All records go to one dataset. Every record has `itemType` (`review` or `game-details`) and `scrapedAt` (ISO timestamp). Missing values are `null`.

#### Review records (`itemType`: review)

| Field | Type | Description |
|---|---|---|
| `appId` | integer | Steam App ID of the game |
| `appName` | string | Game name |
| `reviewId` | string | ID of the review |
| `votedUp` | boolean | Whether the review recommends the game |
| `text` | string | Review text |
| `language` | string | Review language (the language the reviewer chose) |
| `playtimeAtReviewHrs` | number | Hours played when the review was written (one decimal) |
| `playtimeForeverHrs` | number | Total hours played so far (one decimal) |
| `votesUp` | integer | Number of "helpful" votes |
| `votesFunny` | integer | Number of "funny" votes |
| `weightedVoteScore` | number | Steam's helpfulness score for the review |
| `commentCount` | integer | Number of comments on the review |
| `steamPurchase` | boolean | Whether the game was bought on Steam |
| `receivedForFree` | boolean | Whether the reviewer got the game for free |
| `earlyAccess` | boolean | Whether the review was written during early access |
| `writtenDuringEarlyAccess` | boolean | Same value as `earlyAccess` (Steam's longer name) |
| `primarilySteamDeck` | boolean | Whether the reviewer played mostly on Steam Deck |
| `refunded` | boolean | Whether the reviewer refunded the game |
| `developerResponse` | string or null | The developer's public reply, if any |
| `developerRespondedAt` | string or null | When the developer replied |
| `createdAt` | string | When the review was posted (ISO) |
| `updatedAt` | string | When the review was last updated (ISO) |
| `sourceUrl` | string | Link to the game's Steam store page |

#### Game details records (`itemType`: game-details)

| Field | Type | Description |
|---|---|---|
| `appId`, `appName` | integer, string | App ID and name |
| `type` | string | Steam item type, e.g. `game` |
| `shortDescription` | string | The store page's short description |
| `developers`, `publishers` | list of strings | As listed on the store page |
| `releaseDate` | string | Release date as Steam shows it |
| `releaseDateIso` | string or null | Release date as `YYYY-MM-DD`; null for vague dates such as "Coming soon" |
| `comingSoon` | boolean | Whether the game is unreleased |
| `isFree` | boolean | Whether the game is free to play |
| `priceInitial`, `priceFinal` | number or null | Price before and after discount, in major units (14.99); null for free games |
| `discountPercent` | number or null | Current discount |
| `currency` | string or null | Price currency for the chosen country |
| `country` | string | Country used for prices |
| `platforms` | object | `windows`, `mac`, `linux` true/false |
| `genres`, `categories` | list of strings | Steam genres and store categories |
| `metacriticScore` | integer or null | Metacritic score, when listed |
| `recommendationsTotal` | integer or null | Number of recommendations |
| `headerImage`, `storeUrl` | string | Header image URL and store page link |
| `summaryLanguage`, `summaryFilter` | string | Language and review filter used for the summary |
| `reviewScore`, `reviewScoreDesc` | integer, string | Steam's review score and its label, e.g. "Very Positive" |
| `totalPositive`, `totalNegative`, `totalReviews`, `positivePct` | number | Review counts and positive % for the chosen language |
| `allLanguagesReviewScore`, `allLanguagesReviewScoreDesc`, `allLanguagesTotalPositive`, `allLanguagesTotalNegative`, `allLanguagesTotalReviews`, `allLanguagesPositivePct` | number / string | The same summary for all languages |

Review counts include all purchase types (Steam purchases and keys or free copies). For Dota 2 that is about 843,000 English reviews.

### Sources and terms

| Source | Access method | Bravona's pacing |
|---|---|---|
| Steam reviews | Steam's `IUserReviewsService/GetAppReviews` JSON endpoint, no key | About 1 request per second (100 reviews per request) |
| Steam store details | Public JSON `store.steampowered.com/api/appdetails` (not in the Steam Web API docs, so it could change) | 1 request every 2 seconds |
| Steam store search | Public JSON `store.steampowered.com/api/storesearch` | 1 request every 2 seconds |

The Actor backs off on HTTP 429 and 5xx (up to 5 retries, honoring `Retry-After`). Pacing is the Actor's own rate, not a limit published by Steam.

Terms: the [Steam Web API Terms of Use](https://steamcommunity.com/dev/apiterms) say you may not use the Steam Web API or Steam Data for unsolicited marketing communications, and limit use to 100,000 calls to the Steam Web API per day. See also the [Steam Subscriber Agreement](https://store.steampowered.com/subscriber_agreement/). You are responsible for how you use the data.

### How to use Steam Reviews and Store Data Scraper

1. Open the Actor and click **Start**.
2. Enter one or more **App IDs** (e.g. 570) or a **search term** (e.g. "roguelike").
3. Choose a **mode**: reviews, details or both.
4. Set **Max games per search** if you use search terms, and the **review filter**, **language** and **country** if needed.
5. Set **Max reviews per app** to cap the number of reviews and the cost.
6. Start the run, then download the dataset as JSON, CSV or Excel, or fetch it via the Apify API.

### Input

Enter at least one App ID or one search term.

| Field | Required | Default | Description |
|---|---|---|---|
| `appIds` | No\* | none | Steam App IDs (integers), the number in a store URL: `store.steampowered.com/app/570` → 570 |
| `searchTerms` | No\* | none | Game names or keywords. Each term is looked up in Steam's store search; its top results are merged with `appIds` and duplicates removed |
| `maxGamesPerSearch` | No | 5 | Games to take from each search term (1 to 10). Steam's store search returns at most 10 results per term |
| `mode` | No | both | `both`, `reviews` or `details` |
| `reviewFilter` | No | recent | `recent` (newest first), `updated` (recently updated first) or `all` (Steam's "most helpful" sort over the full history) |
| `language` | No | english | `all`, or one of Steam's 31 language codes: arabic, brazilian, bulgarian, czech, danish, dutch, english, finnish, french, german, greek, hungarian, indonesian, italian, japanese, koreana, latam, malay, norwegian, polish, portuguese, romanian, russian, schinese, spanish, swedish, tchinese, thai, turkish, ukrainian, vietnamese |
| `maxReviewsPerApp` | No | 100 | Maximum reviews per game (1 to 50,000); caps cost |
| `country` | No | us | 2-letter country code for prices, currency and store search |

\* At least one of `appIds` or `searchTerms` is required.

Example input (the prefill):

```json
{"appIds":[570],"mode":"both","maxReviewsPerApp":50}
```

On a test build this returned 51 items (50 reviews and 1 game-details record) in about 3 seconds.

### Output examples

Real, unedited records from the example run above (Apify test build 0.1.2, Oct 30, 2026).

Review record:

```json
{
  "itemType": "review",
  "appId": 570,
  "appName": "Dota 2",
  "reviewId": "238941653",
  "votedUp": true,
  "text": "really great game! but also stressful game! so if you love your life. dont play dota!",
  "language": "english",
  "playtimeAtReviewHrs": 3904.6,
  "playtimeForeverHrs": 3904.6,
  "votesUp": 0,
  "votesFunny": 0,
  "weightedVoteScore": 0.5,
  "commentCount": 0,
  "steamPurchase": true,
  "receivedForFree": false,
  "earlyAccess": false,
  "writtenDuringEarlyAccess": false,
  "primarilySteamDeck": false,
  "refunded": false,
  "developerResponse": null,
  "developerRespondedAt": null,
  "createdAt": "2026-10-30T18:29:24.000Z",
  "updatedAt": "2026-10-30T18:29:24.000Z",
  "sourceUrl": "https://store.steampowered.com/app/570",
  "scrapedAt": "2026-10-30T19:51:01.465Z"
}
```

Game details record:

```json
{
  "itemType": "game-details",
  "appId": 570,
  "appName": "Dota 2",
  "type": "game",
  "shortDescription": "Every day, millions of players worldwide enter battle as one of over a hundred Dota heroes. And no matter if it's their 10th hour of play or 1,000th, there's always something new to discover. With regular updates that ensure a constant evolution of gameplay, features, and heroes, Dota 2 has taken on a life of its own.",
  "developers": [
    "Valve"
  ],
  "publishers": [
    "Valve"
  ],
  "releaseDate": "Jul 9, 2013",
  "releaseDateIso": "2013-07-09",
  "comingSoon": false,
  "isFree": true,
  "priceInitial": null,
  "priceFinal": null,
  "discountPercent": null,
  "currency": null,
  "country": "us",
  "platforms": {
    "windows": true,
    "mac": true,
    "linux": true
  },
  "genres": [
    "Action",
    "Strategy",
    "Free To Play"
  ],
  "categories": [
    "Multi-player",
    "Co-op",
    "Steam Trading Cards",
    "Steam Workshop",
    "SteamVR Collectibles",
    "In-App Purchases",
    "Camera Comfort",
    "Color Alternatives",
    "Custom Volume Controls",
    "Valve Anti-Cheat enabled",
    "Steam Timeline"
  ],
  "metacriticScore": 90,
  "recommendationsTotal": 14371,
  "headerImage": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/570/header.jpg?t=1791407503",
  "storeUrl": "https://store.steampowered.com/app/570",
  "summaryLanguage": "english",
  "summaryFilter": "recent",
  "reviewScore": 8,
  "reviewScoreDesc": "Very Positive",
  "totalPositive": 740349,
  "totalNegative": 102430,
  "totalReviews": 842779,
  "positivePct": 87.8,
  "allLanguagesReviewScore": 8,
  "allLanguagesReviewScoreDesc": "Very Positive",
  "allLanguagesTotalPositive": 2256605,
  "allLanguagesTotalNegative": 550146,
  "allLanguagesTotalReviews": 2806751,
  "allLanguagesPositivePct": 80.4,
  "scrapedAt": "2026-10-30T19:51:01.465Z"
}
```

Each run also writes an `OUTPUT` record to its key-value store: the resolved input, each search term and the App IDs it produced, and per-game status for details and reviews (count, pages, stop reason and Steam's matching total). Per game, `details.chargeRequested` is true when the details record was saved with its charge event, and `details.charged` / `reviews.charged` show what Apify actually charged; `charging.payPerEvent` says whether the run had pay-per-event pricing at all.

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

You pay only for records saved to your dataset.

| Event | When it is charged | Price |
|---|---|---|
| Actor start | Once per run | $0.00005 |
| Review returned | Each review saved | $0.0006 ($0.60 per 1,000) |
| Game details returned | Each game's details record saved, once per game per run | $0.002 ($2.00 per 1,000) |

Examples (upper bounds: a game can have fewer reviews than the cap, and a search can return fewer games):

- Prefilled run (1 game, mode both, 50 reviews): 50 × $0.0006 + 1 × $0.002 = **$0.032**, plus the $0.00005 start fee.
- Defaults, 1 game (mode both, 100 reviews): up to 100 × $0.0006 + 1 × $0.002 = about **$0.062**, plus the start fee.
- Defaults, 1 search term (5 games, mode both, 100 reviews each): up to 500 × $0.0006 + 5 × $0.002 = about **$0.31**, plus the start fee.
- 1,000 reviews cost $0.60; details for 100 games cost $0.20.

Games Steam returns no details for (for example, not sold in your chosen country) get no details record and are not charged.

The Actor respects the maximum cost you set for the run (Apify's standard spending limit): when the limit is reached it stops cleanly.

Platform usage (compute, proxy, storage) is included in these prices. You pay only the event prices listed above, nothing extra on top.

Works on Apify's free plan; you pay a tiny start fee plus only for results returned (each review and each game-details record saved). Charges come out of your Apify account's prepaid usage; on the Free plan, once that monthly usage is used up, runs stop until the next billing cycle.

### Limits

- The Actor paces itself (about 1 request per second for reviews, 1 every 2 seconds for details and search), so large runs take time: 50,000 reviews for one game take about 9 minutes.
- The store details endpoint is not part of Steam's documented Web API and could change or be throttled.
- Up to 50,000 reviews per game, and up to 10 games per search term (Steam's store search returns at most 10).
- Store search results can include DLC and soundtracks, not only games.
- Games not sold in your chosen country get no details record (and no charge); their reviews are still collected.
- Free games have null prices; vague release dates give a null `releaseDateIso`.
- Reviewer Steam IDs, usernames, profile data and other author data are not included.

### FAQ

**Is it legal to use this data?** The Actor reads public Steam data without logging in. Review text is public user content: use it for analysis, not republishing. The [Steam Web API Terms of Use](https://steamcommunity.com/dev/apiterms) forbid using Steam Data for unsolicited marketing communications. You are responsible for how you use the data. This is not legal advice.

**Does it include reviewer profiles or Steam IDs?** No. No reviewer IDs, usernames, profile links or other author data are output.

**Which languages are supported?** `all`, or any of Steam's 31 language codes (default `english`). Steam tags each review with the language the reviewer chose.

**Can I get every review for a game?** In testing, yes: on Oct 30, 2026, a game with 2,301 English reviews returned 2,300 of them with each review filter, at about 6,000 reviews a minute. That is an observed test result on a mid-size game, not a guarantee for every game. Set **Max reviews per app** as high as 50,000.

**Why are review totals higher than on some other tools?** The Actor counts reviews from all purchase types, not only Steam purchases. Dota 2 shows about 843,000 English reviews.

**Why do I get at most 10 games per search term?** Steam's store search returns at most 10 results per term. Use App IDs for more games.

**A game has reviews but no details record. Why?** Steam returned no store details for it in your country (removed, region-locked or not a store app). Its reviews are still collected and no details are charged. Try another country.

**Do I pay for Apify compute on top?** No. Platform usage is included. You pay only the listed event prices: $0.00005 per run start, $0.0006 per review and $0.002 per game's details.

**Can I use it via API or integrations?** Yes, like any Apify Actor, through the API tab, schedules and integrations.

**Something broke or a field is missing?** Open an issue in the **Issues** tab.

### Changelog

- **0.1** (Unreleased): Initial release. Steam reviews and game details by App ID or store search term, in one dataset; review filters (recent, updated, all), 31 languages or all, up to 50,000 reviews per game; prices for any country; review summary stats for the chosen language and all languages; no reviewer IDs or author data; pay per event.

### Disclaimer

Steam Reviews and Store Data Scraper is an unofficial tool built by Bravona. It is not affiliated with, endorsed by, or sponsored by Valve Corporation or Steam. All product names and trademarks belong to their owners and are used only to describe compatibility. The Actor reads publicly available data through public Steam endpoints without logging in, and follows a conservative request rate. Data is provided as-is; accuracy and availability depend on the source. You are responsible for using the data in line with Steam's terms and applicable law (including privacy law).

# Changelog

This Actor's version history is a separate document: https://apify.com/bravona/steam-reviews-and-store-data/changelog.md

# Actor input Schema

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

Optional. Steam App IDs, the number in a store URL (store.steampowered.com/app/570 → 570). At least one of App IDs or search terms is required. Combined with search results as a deduplicated union.

## `searchTerms` (type: `array`):

Optional. Game names or keywords. Each term is looked up in Steam's public store search (store.steampowered.com/api/storesearch, using the country below) and the top results are added to the App IDs as a deduplicated union. At least one of App IDs or search terms is required.

## `maxGamesPerSearch` (type: `integer`):

How many of the top store-search results to take per search term. 1 to 10, default 5 (Steam's store search returns at most 10 results per term).

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

reviews: only review records. details: only one game-details record per game (store details plus review summary stats). both (default): both record types.

## `reviewFilter` (type: `string`):

recent (default): newest created first. updated: most recently updated first. all: Steam's 'most helpful' sort over the full history (day_range 0). All three page with Steam's cursor until Steam returns an empty page, which then repeats the last cursor; in tests on Oct 30, 2026 each value paged through 2,300 of 2,301 English reviews on a mid-size game. The Actor stops on an empty page, a repeated cursor, a page with no new review IDs, or the max below.

## `language` (type: `string`):

Steam API language code of the reviews to fetch, or 'all' for every language. Default english. The review summary stats in game-details use the same language; an all-languages summary is always included too. Codes from Steam's 'Languages Supported on Steam' page (API language code column), e.g. schinese = Simplified Chinese, koreana = Korean, brazilian = Portuguese-Brazil, latam = Spanish-Latin America.

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

Maximum review records per game. 1 to 50,000, default 100. Fetched 100 per request at about 1 request per second, so 50,000 reviews for one game takes about 9 minutes. Fewer are returned if the game has fewer reviews in the chosen language.

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

2-letter ISO 3166 country code passed to Steam as cc= for prices, currency and store search. Default us. If a game isn't sold in that country Steam returns no store details: the game gets no game-details record (and no charge), but its reviews are still collected.

## Actor input object example

```json
{
  "appIds": [
    570
  ],
  "maxGamesPerSearch": 5,
  "mode": "both",
  "reviewFilter": "recent",
  "language": "english",
  "maxReviewsPerApp": 50,
  "country": "us"
}
```

# Actor output Schema

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

All saved records in the default dataset. Opens on the Overview view; switch to the Reviews or Game details view in Console.

## `summary` (type: `string`):

The OUTPUT record in the default key-value store: resolved input, searches, per-game status, totals and charged events.

# 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": [
        570
    ],
    "mode": "both",
    "maxReviewsPerApp": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("bravona/steam-reviews-and-store-data").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": [570],
    "mode": "both",
    "maxReviewsPerApp": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("bravona/steam-reviews-and-store-data").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": [
    570
  ],
  "mode": "both",
  "maxReviewsPerApp": 50
}' |
apify call bravona/steam-reviews-and-store-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bravona/steam-reviews-and-store-data"
        }
    }
}
```

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/nRY9795ntE2AHF24Z/builds/ccLWBdX3nyP0QxB9W/openapi.json