# Steam Review Analysis: Game Reviews, Playtime & Sentiment (`precious_bathmat/steam-reviews-scraper`) Actor

For game developers, publishers and analysts: Steam reviews by game name, link or app id with text, thumbs up or down, hours played, language, votes and developer replies, plus a report with Steam score, monthly trend, top complaints and praise.

- **URL**: https://apify.com/precious_bathmat/steam-reviews-scraper.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Games, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reviews

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 Review Analysis: Game Reviews, Playtime & Sentiment

Scrape **Steam game reviews** by game name, store link or app id, with no login and no API key, and get a **report for every game**:

- **Every review**: full text, **recommended or not**, **hours played** at review and in total, language, helpful and funny votes, dates, Steam Deck, early access, bought on Steam or not, **developer reply**
- **Filters**: newest, recently updated or most helpful; positive or negative only; any Steam language; reviews since a date
- **Report per game**: Steam score and totals, **reviews by month** since launch, the **last 30 days**, **hours played by happy and unhappy players**, languages, OS and Steam Deck share, **top complaint and praise phrases**, plus price, discount, release date, developers, genres and Metacritic score

### What does this Steam review scraper do?

```
Cities: Skylines II · Mixed · 93,580 reviews · 56% positive
 Last 30 days: 739 reviews, 70% positive (recovering)
 Unhappy players: median 36 h played before the thumbs down
 Complaints: "without mods", "performance issues", "steam workshop"
 $49.99 · Iceflake Studios, Colossal Order · Simulation
```

1. Enter **games**: names, Steam links or app ids.
2. Pick the **order**, **positive / negative**, **language** and how many reviews.
3. You get **one row per review** and **one report per game**.

```mermaid
flowchart LR
    A[Game names,<br/>links or ids] --> B[Steam store<br/>search]
    B --> C[Reviews<br/>100 per page]
    B --> D[Review history<br/>by month]
    B --> E[Price, genres,<br/>developers]
    C --> F[Report per game]
    D --> F
    E --> F
```

### Who is it for?

- **Game developers and publishers**: what players complain about after a patch, and whether recent reviews are recovering
- **Indie studios and marketers**: what players praise in competing games before you build or pitch yours
- **Market and investment analysts**: review momentum by month as a proxy for sales and player interest
- **Journalists and content creators**: the real player verdict on a launch, by language and playtime
- **Data scientists**: labelled sentiment data (thumbs up or down) in 25+ languages for training and testing models

### What data do you get?

**Reviews** (dataset, one row per review)

| Field | What it tells you |
|---|---|
| `game`, `appId`, `reviewId`, `url` | The game and the review |
| `recommended`, `review`, `reviewLength`, `language` | Thumbs up or down, and the full text |
| `createdAt`, `updatedAt`, `edited` | When it was written and last changed |
| `helpfulVotes`, `funnyVotes`, `helpfulnessScore`, `comments` | How other players rated the review |
| `hoursAtReview`, `hoursTotal`, `hoursLastTwoWeeks` | How long the reviewer had played |
| `reviewerGamesOwned`, `reviewerReviews` | How experienced the reviewer is (no name or id) |
| `boughtOnSteam`, `receivedForFree`, `earlyAccessReview`, `steamDeck`, `refunded` | Steam's review flags |
| `os`, `gpu` | The reviewer's system, when Steam shows it |
| `developerResponse`, `developerRespondedAt` | The developer's public reply |

**Report** (`REPORTS`, one per game; `REPORTS_CSV` as a flat sheet)

| Field | What it tells you |
|---|---|
| `steamScore`, `totalReviews`, `totalPositive`, `totalNegative`, `positivePercent` | Steam's own score and counts |
| `reviewsByMonth`, `last30DaysReviews`, `last30DaysPositivePercent`, `last3MonthsPositivePercent` | Every review over time, all languages |
| `reviewsRead`, `readPositivePercent`, `readFrom`, `readTo` | The reviews this run read |
| `medianHoursAtReview`, `medianHoursPositive`, `medianHoursNegative`, `negativeUnder2HoursPercent` | Who leaves which verdict, and when |
| `languages`, `operatingSystems`, `steamDeckPercent`, `earlyAccessReviewsPercent`, `developerRepliedPercent` | Who the reviewers are |
| `negativeTerms`, `positiveTerms`, `mostHelpfulNegative` | What players complain about and praise |
| `price`, `discountPercent`, `releaseDate`, `developers`, `publishers`, `genres`, `features`, `platforms`, `metacritic` | Store details |

### Example: 1 November 2026

Five games, the 1,000 newest reviews each (5,000 reviews in 90 seconds):

| Game | Steam score | All reviews | Positive | Last 30 days | Median hours: happy / unhappy |
|---|---|---|---|---|---|
| Hades | Overwhelmingly Positive | 310,565 | 98% | 1,551 reviews, 96% | 25 / 22 |
| Baldur's Gate 3 | Overwhelmingly Positive | 864,046 | 97% | 3,732 reviews, 95% | 126 / 41 |
| Counter-Strike 2 | Very Positive | 9,957,945 | 86% | 72,613 reviews, 79% | 100 / 262 |
| Cities: Skylines II | Mixed | 93,580 | 56% | 739 reviews, 70% | 33 / 36 |
| Starfield | Mixed | 175,906 | 57% | 335 reviews, 64% | 83 / 29 |

Counter-Strike 2's unhappy players had played **262 hours** (cheaters and bans are the top complaint), while Starfield's gave up after a median 29 hours, with "loading screens" and "main quest" among the top complaints.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Review saved | $0.0005 |
| Game report | $0.01 |

1,000 reviews with a report cost **$0.51**. Platform usage is small: 5,000 reviews used about $0.02 of compute.

### Good to know

- **Speed**: Steam returns 100 reviews per request and the Actor sends one request a second, so a run reads up to **6,000 reviews a minute**.
- **Totals and filters**: `totalReviews` and `positivePercent` are Steam's own counts for your language, review type and purchase filters. `reviewsByMonth` and the last 30 days always cover every review in every language.
- **Phrases**: complaint and praise phrases are counted over the **English** reviews read (`termsFromEnglishReviews` says how many). For other languages, use the review text directly.
- **Most helpful**: this order covers reviews from the last `helpfulDays` days (up to a year). `reviewsSince` works with the newest-first and recently-updated orders.
- **Free games** have no price; `isFree` is `true`.
- **No personal data**: reviewer names, Steam ids, profile links and avatars are not collected.

### Input

| Field | Default | What it does |
|---|---|---|
| `games` | – | Game names, Steam links or app ids |
| `maxReviewsPerGame` | `200` | Most reviews per game (0 = report only, up to 100,000) |
| `sort` | `recent` | `recent`, `updated` or `helpful` |
| `reviewType` | `all` | `all`, `positive` or `negative` |
| `language` | `all` | A Steam language name, e.g. `english`, `schinese`, `russian`, `brazilian` |
| `purchaseType` | `all` | `all`, `steam` or `other` (keys bought elsewhere) |
| `reviewsSince` | – | Only reviews written on or after this date |
| `helpfulDays` | `365` | Days covered by the most-helpful order |
| `country` | `us` | Store country for prices |
| `includeGameDetails` | `true` | Price, genres, developers and more in each report |
| `includeReports` | `true` | One report per game |

```json
{
  "games": ["Starfield", "https://store.steampowered.com/app/1086940/"],
  "maxReviewsPerGame": 2000,
  "reviewType": "negative",
  "language": "english",
  "reviewsSince": "2026-10-01"
}
```

### Integrations

Run it weekly after each patch to track sentiment, send reviews to **Google Sheets**, **BigQuery** or a sentiment model, or call it from **Make**, **Zapier**, **n8n** or the **Apify API**. The `REPORTS_CSV` record opens directly in any spreadsheet.

### Related tools

Other tools from the same publisher that pair well with this one:

- [Long-Tail Keyword Finder: Google, YouTube, Amazon, Bing](https://apify.com/precious_bathmat/long-tail-keyword-finder)
- [Google Trends Keyword Report: Trends, Seasons & Breakouts](https://apify.com/precious_bathmat/google-trends-keyword-report)
- [Pinterest Keyword Research: Top Pins, Saves & Websites](https://apify.com/precious_bathmat/pinterest-keyword-research)
- [Google Ads Competitor Tracker: Ads, Formats & Countries](https://apify.com/precious_bathmat/google-ads-competitor-tracker)

# Actor input Schema

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

Game names ("Hades", "Baldur's Gate 3"), Steam store links or app ids (1145360), one per line.

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

Most reviews to save per game (0 to 100,000). 0 = report only. About 6,000 reviews a minute.

## `sort` (type: `string`):

Steam's review order.

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

Keep all reviews, or only thumbs up or thumbs down.

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

"all" or a Steam language name: english, schinese, russian, spanish, latam, brazilian, german, french, japanese, koreana, polish, turkish ...

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

Where the reviewer got the game.

## `reviewsSince` (type: `string`):

Optional: only reviews written on or after this date (newest-first and recently-updated orders).

## `helpfulDays` (type: `integer`):

With the "Most helpful" order: reviews from the last N days (1 to 365).

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

Two-letter country for prices, e.g. us, gb, de, in, br.

## `includeGameDetails` (type: `boolean`):

Add price, discount, release date, developers, publishers, genres, platforms and Metacritic score to each report.

## `includeReports` (type: `boolean`):

One report per game: Steam score and totals, reviews by month, last 30 days, playtime of positive and negative reviewers, languages, OS, Steam Deck share and top complaint and praise phrases.

## Actor input object example

```json
{
  "games": [
    "Hades",
    "https://store.steampowered.com/app/1086940/Baldurs_Gate_3/"
  ],
  "maxReviewsPerGame": 200,
  "sort": "recent",
  "reviewType": "all",
  "language": "all",
  "purchaseType": "all",
  "helpfulDays": 365,
  "country": "us",
  "includeGameDetails": true,
  "includeReports": true
}
```

# Actor output Schema

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

One row per review: text, recommended, hours played, language, votes, dates, Steam Deck, developer reply.

## `reports` (type: `string`):

Per game: Steam score, totals, reviews by month, playtime, languages, top complaint and praise phrases, price and genres.

## `reportsCsv` (type: `string`):

One flat row per game.

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

Requests, problems and the limits of the data.

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

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/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": [
        "Hades",
        "https://store.steampowered.com/app/1086940/Baldurs_Gate_3/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("precious_bathmat/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": [
    "Hades",
    "https://store.steampowered.com/app/1086940/Baldurs_Gate_3/"
  ]
}' |
apify call precious_bathmat/steam-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,precious_bathmat/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/gc7ft0ppNQ2q19naE/builds/3oJiaMZy3qIywqWpZ/openapi.json