# Steam Reviews Scraper - All Languages + Game Data (`olsols4/steam-reviews-game-data`) Actor

Scrape every Steam user review for any game, in all languages or the ones you pick. Filter by positive/negative, date, playtime and keywords. Includes a game summary row with rating, price, genres and developer. No login, no API key.

- **URL**: https://apify.com/olsols4/steam-reviews-game-data.md
- **Developed by:** [Olly](https://apify.com/olsols4) (community)
- **Categories:** Games, Developer tools
- **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 Reviews Scraper - All Languages + Game Data

**Scrape every Steam user review for any game, in every language or just the ones you pick.** Filter by positive or negative, date range, playtime, purchase type, review length and keywords. Each game also gets a summary row with its all-language rating, review counts, price and discount, release date, developers, publishers, genres and Metacritic score.

✅ All languages in one run   ✅ Many games per run (links, IDs or names)   ✅ Positive / negative, date, playtime and keyword filters   ✅ Game summary row   ✅ No login, no API key, no proxy   ✅ $0.40 per 1,000 reviews, no start fee

### What can you use it for?

- **Game developers and publishers**: track what players say after every patch, find crash and performance complaints, and compare your reviews with competitors'
- **Sentiment analysis and AI training data**: clean, labelled text (recommended yes/no) in 30 languages
- **Market research**: see what players love or hate in a genre before you build or sign a game
- **Localisation QA**: read reviews in each language to spot translation and regional issues
- **Journalism and analytics**: review bombing, review velocity over a date window, Steam Deck feedback

### How to use it

1. Paste Steam store links, app IDs or game names in **Steam games**.
2. Pick **Languages**: `all` (default) or codes such as `english`, `schinese`, `russian`, `german`.
3. Optional filters: review type, purchase type, date range, keywords, minimum playtime, minimum length.
4. Set **Max reviews per game** (per language when you pick several) and click **Start**.
5. Export JSON, CSV or Excel, or use the API. Schedule it with a **From date** to collect only new reviews.

#### Input example

```json
{
  "games": ["https://store.steampowered.com/app/1145360/Hades/", "620", "baldur's gate 3"],
  "languages": ["english", "german"],
  "reviewType": "negative",
  "dateFrom": "2026-09-01",
  "keywords": ["crash", "performance"],
  "maxReviewsPerGame": 2000
}
```

#### Input fields

| Field | What it does |
|---|---|
| `games` | Store links, app IDs or names (top Steam search match). |
| `maxReviewsPerGame` | Cap per game (and per language when several are picked). `0` = summary row only. |
| `languages` | `all`, or Steam language codes. |
| `reviewType` | `all`, `positive` or `negative`. |
| `purchaseType` | `all`, `steam` (bought on Steam) or `non_steam_purchase` (keys). |
| `sortBy` | `recent` (newest first), `updated` or `helpful`. |
| `dateFrom` / `dateTo` | Date window (YYYY-MM-DD). With newest-first the run stops at the window's start, so you only pay for the window. |
| `keywords`, `minPlaytimeHours`, `minTextLength` | Text and quality filters. |
| `includeGameSummary`, `priceCountry` | Adds one summary row per game, with the price in that country's store. |

### Output

Review row:

```json
{
  "type": "review",
  "appId": 1145360,
  "gameName": "Hades",
  "reviewId": "237394428",
  "recommended": false,
  "text": "98% for a good game, but that gets repetitive fast is nonsense.",
  "language": "english",
  "createdAt": "2026-10-10T18:08:03+00:00",
  "updatedAt": "2026-10-10T18:08:03+00:00",
  "votesHelpful": 0,
  "votesFunny": 0,
  "weightedVoteScore": 0.476,
  "commentCount": 0,
  "steamPurchase": false,
  "receivedForFree": false,
  "writtenDuringEarlyAccess": false,
  "primarilySteamDeck": false,
  "developerResponse": null,
  "author": "Tomb",
  "authorPlaytimeHours": 36.6,
  "authorPlaytimeAtReviewHours": 36.6,
  "authorGamesOwned": 0,
  "authorReviewCount": 10
}
```

Game summary row:

```json
{
  "type": "game",
  "appId": 1145360,
  "gameName": "Hades",
  "url": "https://store.steampowered.com/app/1145360/",
  "reviewScoreDesc": "Overwhelmingly Positive",
  "totalReviews": 309983,
  "totalPositive": 303756,
  "totalNegative": 6227,
  "positivePercent": 98.0,
  "priceCountry": "US",
  "currency": "USD",
  "price": 24.99,
  "discountPercent": 0,
  "releaseDate": "Sep 17, 2020",
  "developers": ["Supergiant Games"],
  "publishers": ["Supergiant Games"],
  "genres": ["Action", "Indie", "RPG"],
  "platforms": ["windows", "mac"],
  "metacriticScore": 93
}
```

The dataset has two views: **Reviews** and **Game summary**. Filter on `type` in the API.

### How much does it cost?

Pay per event, no start fee:

- **$0.40 per 1,000 reviews** ($0.0004 per review)
- **$0.002 per game summary row** (turn it off if you don't need it)

**Worked examples**

- 1,000 reviews of one game + its summary = $0.40 + $0.002 = **$0.40**
- Latest 500 reviews for each of 10 competitor games = 5,000 × $0.0004 + 10 × $0.002 = **$2.02**
- Weekly check of 3 games with `dateFrom` = last week, ~300 new reviews = **$0.13 a week**
- Summary rows only for 200 games (`maxReviewsPerGame: 0`) = **$0.40**

Filtered-out reviews are never charged.

### Use it via API

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("olsols4/steam-reviews-game-data").call(run_input={
    "games": ["1145360"], "languages": ["all"], "reviewType": "negative", "maxReviewsPerGame": 500})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "review":
        print(row["language"], row["recommended"], row["text"][:80])
```

Or with plain HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/olsols4~steam-reviews-game-data/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" -d '{"games":["620"],"maxReviewsPerGame":100}'
```

Send results to Google Sheets, Slack, Make, Zapier, n8n or a webhook through Apify integrations.

### FAQ

**How many reviews can I get?** All of them. Steam pages through a game's full review history; very popular games have hundreds of thousands, so set a cap or a date window.

**Why can the review count differ slightly from Steam's headline number?** Steam's headline count excludes some reviews (e.g. off-topic review bombs, free keys), and this Actor filters off-topic review-bomb activity by default, as Steam's store page does.

**What reviewer data is included?** The public display name and playtime stats shown next to each review on Steam. Steam IDs, profile links and avatars are not collected.

**Do I need a Steam account or API key?** No. It uses the same public review feed as the Steam store page.

**Does it work for DLC, demos and software?** Yes, anything with a Steam app ID and reviews.

**Which language codes are supported?** all, english, schinese, tchinese, russian, spanish, latam, brazilian, portuguese, german, french, italian, japanese, koreana, polish, turkish, ukrainian, thai, vietnamese, czech, dutch, swedish, danish, finnish, norwegian, hungarian, romanian, greek, bulgarian, arabic, indonesian.

### Support

Need a field or found a game that fails? Open an issue on the **Issues** tab. Issues are answered within a few days.

# Actor input Schema

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

Steam store links (https://store.steampowered.com/app/1145360/Hades/), app IDs (1145360) or game names (the top Steam search match is used).

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

Upper limit of reviews saved per game, and per language when you pick several languages. Set 0 for the summary row only.

## `languages` (type: `array`):

'all' for every language in one stream, or Steam language codes: all, english, schinese, tchinese, russian, spanish, latam, brazilian, portuguese, german, french, italian, japanese, koreana, polish, turkish, ukrainian, thai, vietnamese, czech, dutch, swedish, danish, finnish, norwegian, hungarian, romanian, greek, bulgarian, arabic, indonesian.

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

Keep all reviews, or only positive or only negative ones.

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

Filter by where the reviewer got the game.

## `sortBy` (type: `string`):

Newest first is best for full exports and date ranges. Most helpful returns Steam's top-rated reviews first.

## `dateFrom` (type: `string`):

Only reviews posted on or after this date (YYYY-MM-DD). With 'Newest first' the run stops as soon as it reaches older reviews, so you only pay for the window.

## `dateTo` (type: `string`):

Only reviews posted on or before this date (YYYY-MM-DD).

## `keywords` (type: `array`):

Keep only reviews whose text contains any of these (e.g. crash, performance, price).

## `minPlaytimeHours` (type: `integer`):

Skip reviews written with less playtime than this.

## `minTextLength` (type: `integer`):

Skip very short reviews (e.g. set 50 to drop one-liners).

## `includeGameSummary` (type: `boolean`):

One row per game with all-language rating, review counts, price, discount, release date, developers, publishers, genres and Metacritic score.

## `priceCountry` (type: `string`):

Two-letter country code for the price in the summary row (us, gb, de, jp...).

## `useApifyProxy` (type: `boolean`):

Steam's public endpoints normally work without a proxy. Turn on only if you see rate-limit errors on very large runs.

## Actor input object example

```json
{
  "games": [
    "https://store.steampowered.com/app/1145360/Hades/",
    "620",
    "baldur's gate 3"
  ],
  "maxReviewsPerGame": 50,
  "languages": [
    "all"
  ],
  "reviewType": "all",
  "purchaseType": "all",
  "sortBy": "recent",
  "minPlaytimeHours": 0,
  "minTextLength": 0,
  "includeGameSummary": true,
  "priceCountry": "us",
  "useApifyProxy": false
}
```

# Actor output Schema

## `reviews` (type: `string`):

Reviews in a table view.

## `games` (type: `string`):

Game summary rows.

## `allItems` (type: `string`):

Every row with every field.

# 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": [
        "https://store.steampowered.com/app/1145360/Hades/"
    ],
    "maxReviewsPerGame": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("olsols4/steam-reviews-game-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 = {
    "games": ["https://store.steampowered.com/app/1145360/Hades/"],
    "maxReviewsPerGame": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("olsols4/steam-reviews-game-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 '{
  "games": [
    "https://store.steampowered.com/app/1145360/Hades/"
  ],
  "maxReviewsPerGame": 50
}' |
apify call olsols4/steam-reviews-game-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,olsols4/steam-reviews-game-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/Sf4mXbn5scFJH0cCn/builds/5iuSBvjYWlOqo46Ib/openapi.json