# Steam Reviews Scraper — reviews, playtime, tags, histogram (`scraper0917/steam-reviews-scraper`) Actor

Every Steam review with playtime at review, helpful/funny votes, purchase type, free-copy, refund, early-access and Steam Deck flags, edits, developer replies, author stats, plus a full game record: price, genres, community tags, review score, monthly histogram. No key, no login.

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

## Pricing

from $0.80 / 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

Pulls reviews for any Steam game through Steam's own public store endpoints, so the data is complete and exact: every field Steam exposes per review, joined to a full game record. No API key, no login, no proxies.

### What you get per review

Text, language, word count, recommended or not, helpful and funny votes, weighted vote score, comment count, purchase type (Steam or key), **received for free**, **refunded**, written during early access, primarily on Steam Deck, created and updated timestamps with an **edited** flag, **developer response** with date, reactions, and the author: Steam ID, name, avatar, games owned, reviews written, last played, plus **playtime at the time of the review**, total playtime, and last two weeks.

With `flattenGameInfo` on (default), each review row also carries the game's release date, price, genres, top ten community tags, review score bucket and positive percentage, so one CSV is analysis-ready.

### What you get per game

Name, type, free flag, price with discount, release date, developers, publishers, genres, categories, platforms, Metacritic score, supported languages, achievements count, DLC count, content descriptors, controller support, screenshots, website, plus:

- **Review summary**: Steam's score bucket ("Very Positive"), totals, positive percentage
- **Community tags** with vote counts, and Steam Deck verification status
- **Review histogram**: monthly positive/negative counts over the game's lifetime and recent weeks
- **SteamSpy estimates** (optional): owners, average and median playtime, concurrent users

### Example review

```json
{
  "type": "review",
  "gameName": "Stardew Valley",
  "recommended": true,
  "text": "500 hours in and I still find new things…",
  "language": "english",
  "votesHelpful": 42, "votesFunny": 3,
  "steamPurchase": true, "receivedForFree": false, "refunded": false,
  "writtenDuringEarlyAccess": false, "primarilySteamDeck": true,
  "createdAt": "2026-08-30T18:59:17.000Z", "edited": false,
  "playtimeAtReviewHours": 512.3, "playtimeTotalHours": 540.1,
  "developerResponse": null,
  "author": { "steamId": "7656119…", "name": "…", "gamesOwned": 100, "reviewsWritten": 5 },
  "gameTags": ["Farming Sim", "Pixel Graphics", "Relaxing", "…"],
  "gamePositivePercent": 97.9
}
```

### Input

| Field | Default | Notes |
|---|---|---|
| `games` | — | app IDs, store URLs, or names (resolved via Steam search) |
| `maxReviewsPerGame` | 500 | 0 = all (Dota 2 has 2.7 million) |
| `language` | `all` | Steam language codes, comma-separated |
| `reviewType` | all | `positive` / `negative` |
| `purchaseType` | all | `steam` / `non_steam_purchase` |
| `sort` | recent | `recent`, `updated`, or `all` (most helpful) |
| `sinceDate` / `untilDate` | — | real date windows; with `recent` or `updated` the walk stops at the boundary, so you only pay for what matches |
| `minPlaytimeHours`, `minHelpfulVotes` | 0 | quality floors |
| `includeGameDetails`, `includeTags`, `includeHistogram`, `includeSteamSpy` | on, on, on, off | game record parts |
| `flattenGameInfo`, `includeAuthor` | on | per-review enrichment |
| `countryCode` | us | store region for prices |

### Uses

- **Sentiment over time**: histogram plus dated reviews with `edited` flags show review bombs and recoveries.
- **Playtime-weighted analysis**: filter by `playtimeAtReviewHours` to separate refund-window reviews from long-term players.
- **Monitoring**: schedule with `sinceDate` yesterday and `sort: recent`; only new reviews are fetched and billed.
- **Market research**: run on a genre's top 50 games with `maxReviewsPerGame: 0` for a full corpus with tags and prices attached.
- **Developer response tracking**: `developerResponse` is non-null wherever the studio replied.

### Notes

- Steam serves the same data to everyone; the Actor paces requests and needs no proxy.
- Date windows with `sort: all` (helpfulness order) cannot stop early, so they scan Steam's 365-day helpful window and filter.
- SteamSpy owner counts are third-party estimates, off by default.
- One `game` item and one `review` item each count as one result.

### Support

Open an Issue on the Actor page; Steam markup changes (tags, Deck badge) are fixed quickly.

# Actor input Schema

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

Steam app IDs, store URLs, or game names (names are resolved through Steam search). One per line.

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

0 = every review Steam will page through (can be millions for big titles).

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

`all`, or a Steam language code such as `english`, `schinese`, `russian`, `german`, `brazilian`, `japanese`, `koreana`, `spanish`, `french`. Comma-separate several: `english,german`.

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

Filter by thumbs up / thumbs down.

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

Filter by how the reviewer obtained the game.

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

`recent` and `updated` walk chronologically, so date windows stop early and cost nothing extra. `all` is Steam's helpfulness order.

## `sinceDate` (type: `string`):

Only reviews created (or updated, with sort=updated) on/after this date. Use on a schedule to fetch only new reviews.

## `untilDate` (type: `string`):

Only reviews on/before this date.

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

Drop reviews written with less playtime than this.

## `minHelpfulVotes` (type: `integer`):

Drop reviews with fewer helpful votes.

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

Emit one `game` item per title: price, release date, developers, genres, categories, platforms, Metacritic, languages, achievements, DLC count, review score bucket and totals.

## `includeTags` (type: `boolean`):

Add user-voted tags with vote counts, plus Steam Deck compatibility, to the game record (one extra store-page request).

## `includeHistogram` (type: `boolean`):

Add monthly positive/negative review counts over the game's lifetime and recent weeks to the game record.

## `includeSteamSpy` (type: `boolean`):

Add owner estimates, average/median playtime and concurrent users from SteamSpy (third-party estimates).

## `flattenGameInfo` (type: `boolean`):

Adds release date, price, genres, top tags, and review score to every review row so a single table is analysis-ready.

## `includeAuthor` (type: `boolean`):

Reviewer Steam ID, name, avatar, games owned, reviews written, last played.

## `countryCode` (type: `string`):

Two-letter country for prices (`us`, `gb`, `de`, `br`, …).

## Actor input object example

```json
{
  "games": [
    "570",
    "https://store.steampowered.com/app/1245620/ELDEN_RING/",
    "Stardew Valley"
  ],
  "maxReviewsPerGame": 500,
  "language": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "sort": "recent",
  "minPlaytimeHours": 0,
  "minHelpfulVotes": 0,
  "includeGameDetails": true,
  "includeTags": true,
  "includeHistogram": true,
  "includeSteamSpy": false,
  "flattenGameInfo": true,
  "includeAuthor": true,
  "countryCode": "us"
}
```

# Actor output Schema

## `results` (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": [
        "570",
        "https://store.steampowered.com/app/1245620/ELDEN_RING/",
        "Stardew Valley"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper0917/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": [
        "570",
        "https://store.steampowered.com/app/1245620/ELDEN_RING/",
        "Stardew Valley",
    ] }

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

```

## MCP server setup

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