# Steam Reviews Scraper (`neuro-scraper/steam-reviews-scraper`) Actor

Steam Reviews Scraper SD - Steam Reviews Scraper is a game data tool that extracts Steam user reviews of any game via Valve's official keyless API: text, recommendation, votes, playtime, language, dates, developer replies and app details, with filters.

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

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 — Steam user reviews with filters and app details

Steam Reviews Scraper collects user reviews of any Steam game or app through Valve's official review API (`IUserReviewsService/GetAppReviews`), which Valve documents as needing no key. It pages through the reviews 100 at a time until your limit. Optionally it adds the app's store details to every row.

No Steam account, no login and no cookies are used.

#### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `appIds` | list | Cyberpunk 2077 store link (prefill) | App ids (`730`) or store / community links |
| `sort` | select | `recent` | Most recent, recently updated, most helpful, funniest |
| `reviewType` | select | `all` | All, positive only, negative only |
| `purchaseType` | select | `all` | All reviewers, bought on Steam, not bought on Steam |
| `languages` | list | `all` | Steam API language codes: `english`, `german`, `schinese` ... |
| `dateFrom`, `dateTo` | `YYYY-MM-DD` | – | Only reviews written in this window |
| `minPlaytimeHours` | integer | – | Only reviews whose author had played at least this long when writing |
| `helpfulDayRange` | integer | `0` | "Most helpful" only: days back (0 = all time) |
| `includeOffTopic` | boolean | `false` | Include reviews Steam hides as off-topic (review bombs) |
| `includeAppDetails` | boolean | `true` | Add name, type, developers, publishers, release date, price and genres |
| `country` | text | `us` | Store country for the price |
| `includeReviewerIds` | boolean | `false` | Add the reviewer's Steam ID and the review link |
| `maxResults` | integer | `100` | Reviews per app |
| `maxItems` | integer | – | Optional cap on the whole run |
| `proxyConfiguration` | proxy | off | Not needed for Valve's API |

#### Output (one row per review)

| Field | Meaning |
|---|---|
| `reviewId`, `appId`, `appName` | Review id, app id, app name |
| `recommended` | `true` = positive (recommended), `false` = negative |
| `review`, `language` | Review text and its language |
| `createdAt`, `updatedAt` | Written and last edited (UTC) |
| `votesUp`, `votesFunny`, `weightedVoteScore`, `commentCount` | Helpful votes, funny votes, Steam's helpfulness score, comments |
| `steamPurchase`, `receivedForFree`, `writtenDuringEarlyAccess`, `primarilySteamDeck`, `refunded` | Review flags |
| `developerResponse`, `developerRespondedAt` | The developer's reply, when there is one |
| `authorNumReviews`, `authorPlaytimeHours`, `authorPlaytimeAtReviewHours`, `authorPlaytimeLastTwoWeeksHours`, `authorLastPlayedAt` | The reviewer's numbers as shown on the store page |
| `authorSteamId`, `reviewUrl` | Only with `includeReviewerIds` |
| `appReviewScoreDesc`, `appTotalReviews`, `appTotalPositive`, `appTotalNegative` | The app's overall score and review totals (all languages and purchase types) |
| `appType`, `appDevelopers`, `appPublishers`, `appReleaseDate`, `appIsFree`, `appPrice`, `appGenres`, `appStoreUrl` | Store details (with `includeAppDetails`) |
| `input`, `scrapedAt` | Your input and UTC time |

#### Measured limits (2026-10-03, local runs)

- 100 reviews per request: 1,000 reviews of Counter-Strike 2 came in 10 pages in 11 seconds, with no duplicates.
- All filters were checked live: negative-only, English-only, a 2025 date window and at least 10 hours of playtime returned only matching reviews.
- Valve caches anonymous answers for up to 10 minutes, so the newest reviews can be a few minutes behind the store page.
- Steam answers HTTP 429 when its shared anonymous limit is hit; the Actor waits and retries (not seen in our tests).
- Developer replies are rare: 1 of 100 helpful negative Valheim reviews had one.
- `appReleaseDate` is the store's text date, written in the format of the chosen `country`.

#### Example

```json
{"appIds": ["730", "https://store.steampowered.com/app/413150/Stardew_Valley/"], "reviewType": "negative", "languages": ["english"], "maxResults": 500}
```

# Actor input Schema

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

App ids (730) or store / community links (https://store.steampowered.com/app/1091500/Cyberpunk_2077/), one per line.

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

Most recent (best for paging through everything), recently updated, most helpful or funniest.

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

All reviews, only positive (recommended) or only negative ones.

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

Reviews from every reviewer, only from people who bought the app on Steam, or only from people who got it elsewhere (keys, gifts).

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

Steam API language codes, one per line: all, english, german, french, spanish, schinese, russian, brazilian, japanese, koreana ... Default: all.

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

Optional. Date as YYYY-MM-DD.

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

Optional. Date as YYYY-MM-DD.

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

Optional. Only reviews whose author had played at least this many hours when writing.

## `helpfulDayRange` (type: `integer`):

Only for "Most helpful". Look this many days back (max 365). 0 = all time.

## `includeOffTopic` (type: `boolean`):

Steam hides reviews posted during off-topic review bombs by default. Turn on to include them.

## `includeAppDetails` (type: `boolean`):

Adds the app's name, type, developers, publishers, release date, price and genres to every review row (one extra request per app).

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

Two-letter country code for the price in the store details, e.g. us, gb, de, in.

## `includeReviewerIds` (type: `boolean`):

Adds each reviewer's public Steam ID and the review's link. Off by default: a Steam ID identifies a person - turn it on only if you need it.

## `maxResults` (type: `integer`):

How many reviews to return for each app. The Actor pages through Steam's reviews (100 per request) until this number or the end.

## `maxItems` (type: `integer`):

Optional cap on the whole run. Leave empty for no total cap.

## `proxyConfiguration` (type: `object`):

Not needed for Valve's review API. Turn a proxy on only if you see HTTP 429 errors.

## Actor input object example

```json
{
  "appIds": [
    "https://store.steampowered.com/app/1091500/Cyberpunk_2077/"
  ],
  "sort": "recent",
  "reviewType": "all",
  "purchaseType": "all",
  "languages": [
    "all"
  ],
  "helpfulDayRange": 0,
  "includeOffTopic": false,
  "includeAppDetails": true,
  "country": "us",
  "includeReviewerIds": false,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://store.steampowered.com/app/1091500/Cyberpunk_2077/"
    ],
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-scraper/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 = {
    "appIds": ["https://store.steampowered.com/app/1091500/Cyberpunk_2077/"],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-scraper/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 '{
  "appIds": [
    "https://store.steampowered.com/app/1091500/Cyberpunk_2077/"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call neuro-scraper/steam-reviews-scraper --silent --output-dataset

```

## MCP server setup

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