# Steam Game Reviews & Ratings Scraper (`coolinbex/steam-reviews-scraper`) Actor

Scrape Steam game reviews in bulk via Steam's official public reviews API. Extract ratings, sentiment (positive/negative), review text, playtime, helpful votes, reviewer language and purchase type.

- **URL**: https://apify.com/coolinbex/steam-reviews-scraper.md
- **Developed by:** [coolinbex](https://apify.com/coolinbex) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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?

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 Reviews Scraper — Bulk Game Reviews, Ratings & Sentiment Export

Extract **Steam game reviews** at scale — ratings, sentiment, review text, playtime, helpful
votes, language, and purchase type — using Steam's own public reviews API. No login,
no cookies, no API key, and no browser automation required, so there's nothing fragile
to break.

### What this actor does

- Accepts any mix of **Steam appId** (`730`), **store URL**
  (`https://store.steampowered.com/app/730/`), or **plain game name** (`"Counter-Strike 2"`,
  auto-resolved via Steam's search API).
- Paginates through reviews reliably, including a guard against a
  [documented Steam API bug](https://steamcommunity.com/discussions/forum/1/601902348018647373/)
  where the pagination cursor can repeat instead of signalling the end of results.
- Outputs one clean, flat record per review plus a per-game rating summary
  (total positive/negative, review score, "Very Positive" style description).
- Retries transient network/5xx/429 errors with backoff, and fails fast on permanent
  errors (like an invalid appId) instead of wasting compute.
- Works entirely off Steam's public JSON endpoints — no residential proxies needed.

### Who this is for

- **Game developers & publishers** monitoring sentiment after a launch or patch.
- **Market researchers & competitive analysts** comparing reception across titles.
- **Data scientists** building sentiment-analysis or recommendation datasets.
- **Game journalists & content creators** sourcing player quotes and rating trends.

### Input

| Field | Type | Description |
|---|---|---|
| `games` | array of strings | **Required.** Steam appIds, store URLs, or game names. |
| `maxReviewsPerGame` | integer | Max reviews to collect per game. Default `200`. |
| `reviewType` | `all` | `positive` | `negative` | Filter by sentiment. Default `all`. |
| `language` | string | Steam language code, or `all`. Default `all`. |
| `filter` | `recent` | `updated` | `all` | Sort order. `recent` is recommended for full, reliable extraction. Default `recent`. |
| `dayRange` | integer | Only used when `filter` is `all`. Max `365`. |
| `purchaseType` | `all` | `steam` | `non_steam_purchase` | Filter by purchase source. Default `all`. |
| `includeOffTopicActivity` | boolean | Include reviews flagged as off-topic "review bombs". Default `false`. |
| `summaryOnly` | boolean | Skip individual reviews, output only per-game rating summaries. Default `false`. |
| `requestDelayMs` | integer | Delay between requests. Default `350`. |

#### Example input

```json
{
  "games": ["730", "https://store.steampowered.com/app/1245620/ELDEN_RING/", "Hades"],
  "maxReviewsPerGame": 500,
  "reviewType": "all",
  "language": "english",
  "filter": "recent"
}
```

### Output

One dataset item per review:

```json
{
  "appId": "730",
  "appName": null,
  "recommendationId": "231560947",
  "steamId": "76561198769876625",
  "language": "english",
  "review": "Great game, still going strong.",
  "votedUp": true,
  "votesUp": 12,
  "votesFunny": 0,
  "weightedVoteScore": "0.52",
  "commentCount": 0,
  "steamPurchase": true,
  "receivedForFree": false,
  "writtenDuringEarlyAccess": false,
  "timeCreated": "2026-07-29T03:06:15.000Z",
  "timeUpdated": "2026-07-29T03:06:15.000Z",
  "playtimeForeverHours": 189.2,
  "playtimeAtReviewHours": 189.2,
  "numGamesOwned": 42,
  "numReviewsByAuthor": 3,
  "scrapedAt": "2026-09-14T10:00:00.000Z"
}
```

Plus one summary record per game:

```json
{
  "type": "GAME_SUMMARY",
  "appId": "730",
  "appName": null,
  "reviewScore": 9,
  "reviewScoreDesc": "Overwhelmingly Positive",
  "totalPositive": 2100000,
  "totalNegative": 150000,
  "totalReviews": 2250000,
  "reviewsScrapedThisRun": 500
}
```

Download results as JSON, CSV, Excel, or push them straight to your own database via
Apify's integrations.

### Why "recent" instead of "all" for sort order

Steam's `all` filter (sorted by helpfulness) uses a sliding day-range window and is more
prone to the pagination-cursor bug mentioned above. This actor's cursor-loop guard
prevents an infinite loop either way, but `recent`/`updated` terminate cleanly and are
recommended when you want a complete, reliable pull.

### Notes

This actor reads only publicly available review text and public author Steam IDs via
Steam's official `appreviews` endpoint — the same data visible to anyone on the game's
store page. Use responsibly and in line with Steam's terms of service and applicable
data-protection law in your jurisdiction.

# Actor input Schema

## `games` (type: `array`):

Steam games to scrape reviews for. Each entry can be a numeric Steam appId (e.g. 730), a Steam store URL (e.g. https://store.steampowered.com/app/730/), or a free-text game name (e.g. "Elden Ring") which will be auto-resolved to its appId.

## `maxReviewsPerGame` (type: `integer`):

Maximum number of reviews to collect for each game.

## `reviewType` (type: `string`):

Filter reviews by sentiment.

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

Steam language code to filter reviews by (e.g. "english", "schinese", "german"), or "all" for every language.

## `filter` (type: `string`):

How Steam sorts the reviews returned. "Recent" and "Updated" reliably terminate when reviews run out. "All" (sorted by helpfulness) is more prone to a known Steam API pagination quirk on very large review sets; this actor guards against it, but "Recent" is recommended for full, reliable extraction.

## `dayRange` (type: `integer`):

How many days back to look for helpful reviews. Only applies when Sort order is "all". Maximum 365.

## `purchaseType` (type: `string`):

Filter reviews by whether the reviewer purchased the game on Steam.

## `includeOffTopicActivity` (type: `boolean`):

By default Steam filters out reviews flagged as off-topic review-bomb activity. Enable this to include them.

## `summaryOnly` (type: `boolean`):

If enabled, skips saving individual review records and only outputs one aggregate rating-summary record per game. Useful for fast sentiment overviews across many games.

## `requestDelayMs` (type: `integer`):

Polite delay between consecutive Steam API requests, to keep request rates reasonable.

## Actor input object example

```json
{
  "games": [
    "730",
    "1245620"
  ],
  "maxReviewsPerGame": 200,
  "reviewType": "all",
  "language": "all",
  "filter": "recent",
  "dayRange": 365,
  "purchaseType": "all",
  "includeOffTopicActivity": false,
  "summaryOnly": false,
  "requestDelayMs": 350
}
```

# Actor output Schema

## `reviews` (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 = {
    "games": [
        "730",
        "1245620"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coolinbex/steam-reviews-scraper").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 = { "games": [
        "730",
        "1245620",
    ] }

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

```

## MCP server setup

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

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/x3rN8qx2NFVa6onfb/builds/XGoR5afhdN03wtqWb/openapi.json