# Steam Reviews Scraper – Game Reviews & App Details (`forevertools/steam-reviews`) Actor

Steam reviews scraper for any game via Steam's public store endpoints — no login, no API key. User review text, sentiment (thumbs up/down), playtime, votes, language, dates, plus video game data (price, genres, developers, review score). $0.50 per 1,000 reviews.

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

## Pricing

$0.50 / 1,000 review scrapeds

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 & Game Details Scraper (official store API)

Scrape Steam **user reviews** for any game, plus **game details**, using Steam's public store endpoints
(`store.steampowered.com/appreviews` and `store.steampowered.com/api/appdetails`). No login, no cookies,
no browser, no Steam Web API key. One dataset row per review, plus one optional free row per game.

Great for: game market research, player-sentiment tracking, competitor analysis, patch and launch monitoring, building review datasets for NLP, and finding what players praise or complain about.

### How it works

1. You give app IDs (`730`), store links or game names (`Stardew Valley`: the exact store title wins, otherwise the top store-search hit, so check `appName`). An ID, a URL and a name for the same game count once.
2. If `includeAppDetails` is on, the actor first fetches the game's details from the store API (US store, English). An app that doesn't exist gets an error row.
3. It then pages through Steam's review endpoint (up to 100 reviews per request) with your sort, language, review-type and purchase-type filters until `maxReviewsPerApp` is reached or Steam has no more reviews.
4. Each review is normalized into one row and deduplicated by review ID. The game-details row, with the review score summary, is written after the reviews.

Up to 2 games are processed in parallel, with a small delay between requests. HTTP 429 and 5xx responses are retried with backoff (up to 4 retries).

### Features

- Paste app IDs (`730`) or store links (`https://store.steampowered.com/app/730/...`).
- Sort by most recent, recently updated or most helpful (with optional day range).
- Filter by language, positive/negative, and Steam purchase vs. key activation.
- Per review: thumbs up/down, full text, language, created/updated dates, helpful & funny votes, weighted score,
  comment count, Steam purchase / received for free / early access / Steam Deck flags, playtime at review and total playtime (hours).
- Optional free **game details** row per game: developers, publishers, release date, price (USD), genres,
  categories, platforms, Metacritic, and the review score summary (e.g. "Very Positive", total positive/negative).
- A bad app ID never crashes the run: you get a row with `type: "error"` (not charged).

### Use cases

#### Game market research

Pull the newest reviews across a list of competitor games and compare what players complain about, with playtime showing how far in the reviewer was.

#### Sentiment and launch monitoring

Schedule a run with the `recent` sort after a patch or sale and watch the positive/negative split and recent review text.

#### NLP and LLM datasets

Export review text with language, votes and playtime as JSON or CSV. Use `language` to restrict to one language.

#### Publisher and developer feedback loops

Filter to `negative` reviews only, sorted by most helpful, to see the most-endorsed criticisms.

### Input

| Field | Description |
|---|---|
| `apps` | Steam app IDs, store URLs or game names |
| `maxReviewsPerApp` | Max reviews per game (default 200, up to 100,000; 0 = details only) |
| `filter` | `recent` (default), `updated`, or `all` (most helpful) |
| `language` | Steam language code: `all` (default), `english`, `german`, `schinese`, ... |
| `reviewType` | `all` (default), `positive`, `negative` |
| `purchaseType` | `all` (default), `steam`, `non_steam_purchase` |
| `dayRange` | Last N days (max 365); only with `filter: all` |
| `includeAppDetails` | Add one free game-details row per game (default true) |

### Output

```json
{
  "type": "review", "appId": 730, "appName": "Counter-Strike 2", "recommendationId": "236483094",
  "url": "https://store.steampowered.com/app/730/#app_reviews_hash",
  "votedUp": false, "text": "...", "language": "russian",
  "createdAt": "2026-09-29T16:50:29.000Z", "updatedAt": "2026-09-29T16:50:29.000Z",
  "votesUp": 0, "votesFunny": 0, "weightedVoteScore": 0.5, "commentCount": 0,
  "steamPurchase": true, "receivedForFree": false, "writtenDuringEarlyAccess": false, "primarilySteamDeck": false,
  "playtimeForeverHours": 42.8, "playtimeAtReviewHours": 42.8, "authorNumReviews": 1,
  "scrapedAt": "...", "error": null
}
```

Game rows have `type: "app"` with `name`, `developers`, `publishers`, `releaseDate`, `price`, `genres`,
`categories`, `platforms`, `metacritic` and `totalReviews` (`reviewScoreDesc`, `totalPositive`, `totalNegative`, `totalReviews`).
`appName` on review rows is filled only when `includeAppDetails` is on. The review `url` links to the game's store reviews section, not to the individual review.
**Privacy:** no Steam IDs, usernames, avatars or profile links are returned, only the review content and anonymous playtime stats.

### Pricing

Pay per event: **$0.0005 per review** ($0.50 per 1,000). Apify platform usage is billed separately as usual.

- 200 reviews (the default) for one game = $0.10
- 10 games x 500 reviews = 5,000 reviews = $2.50
- 50,000 reviews = $25.00

**Charged:** each review row saved. **Not charged:** game-detail rows, error rows and duplicate reviews. Details-only runs (`maxReviewsPerApp: 0`) cost no review events. If you set a maximum charge for the run, the actor stops before exceeding it.

### Limitations

- `dayRange` only applies to the "most helpful" sort (a Steam restriction).
- With `includeAppDetails: false`, an unknown app ID returns zero reviews instead of an error row.
- Counts and votes are a snapshot at scrape time; deleted or hidden reviews are not returned.
- Prices are USD (US store); no regional prices.
- Not affiliated with Valve or Steam. Built and maintained with AI assistance; problems go to the Issues tab.

### FAQ

**Do I need a Steam account or API key?** No. Everything comes from Steam's public store endpoints.

**How many reviews can I get?** As many as Steam's review pages return for your filters, up to 100,000 per game per run; set `maxReviewsPerApp`.
Very popular games have millions of reviews, so start small.

**Can I get only negative reviews, or only one language?** Yes, use `reviewType` and `language`.

**Can I get only game details, without reviews?** Yes. Set `maxReviewsPerApp` to 0; you get the free details row and score summary.

**Why are the totals different from the store page?** `totalReviews` follows your language / review type / purchase
type filters, and the store page may count reviews differently (e.g. off-Steam activations).

**Can I get regional prices?** Not in this version; prices are the US store price.

**Is this legal / allowed?** It reads only public review data through Steam's public store endpoints at modest
request rates and returns no personal identifiers. You are responsible for how you use the data.

### Related tools

Other actors by the same developer (same flat pay-per-result pricing, no subscription):

- [App Store Reviews Scraper – Apple iOS, Multi-Country](https://apify.com/forevertools/apple-app-store-reviews)
- [Article Scraper & Text Extractor – Clean Markdown for LLM/RAG](https://apify.com/forevertools/article-extractor)
- [Job Postings & Career Page Scraper – Workday, Greenhouse, Lever](https://apify.com/forevertools/ats-company-jobs)
- [Bluesky Posts Scraper – Profiles & Threads, No Login](https://apify.com/forevertools/bluesky-posts)
- [Company Enrichment from Domain (Logo, Socials, Tech)](https://apify.com/forevertools/company-website-enrichment)
- [DNS Lookup & WHOIS Domain Checker — SPF/DMARC, SSL Expiry](https://apify.com/forevertools/domain-whois-dns-ssl)
- [Email Validator & MX Record Checker – Bulk, Disposable, Role](https://apify.com/forevertools/email-syntax-mx-checker)
- [Bulk PageSpeed Insights, Lighthouse & Core Web Vitals](https://apify.com/forevertools/pagespeed-core-web-vitals)
- [PDF Extractor & Parser – Bulk PDF to Text with Metadata](https://apify.com/forevertools/pdf-to-text-extractor)
- [SEO Audit Crawler & Broken Link Checker – Website Health](https://apify.com/forevertools/website-seo-audit)
- [Sitemap Extractor & Bulk URL Status Checker](https://apify.com/forevertools/sitemap-url-status-checker)
- [Website Technology Detector – Tech Stack, CMS & Analytics](https://apify.com/forevertools/website-tech-stack-detector)
- [Website Screenshot API – Bulk Full Page PNG, JPEG & PDF](https://apify.com/forevertools/website-screenshot)

### Integrations

Run it from the Apify API, a schedule, or no-code tools: the Apify apps for **Zapier**, **Make** and **n8n** can start any public actor ("Run Actor") and read its dataset. AI agents can call it through the **Apify MCP server**.

### Ready-made examples

One-click tasks you can run or copy and adapt:

- [Latest negative Steam reviews for Counter-Strike 2](https://apify.com/forevertools/steam-reviews/examples/counter-strike-2-negative-reviews)
- [Compare Steam reviews of hit indie games (Hades, Stardew)](https://apify.com/forevertools/steam-reviews/examples/indie-game-reviews-comparison)
- [Baldur's Gate 3 Steam reviews in German](https://apify.com/forevertools/steam-reviews/examples/baldurs-gate-3-german-reviews)
- [Cyberpunk 2077: recently updated Steam reviews after patches](https://apify.com/forevertools/steam-reviews/examples/cyberpunk-2077-reviews-after-updates)

# Actor input Schema

## `apps` (type: `array`):

Steam app IDs (e.g. 730), store links (e.g. https://store.steampowered.com/app/730/CounterStrike\_2/) or game names (e.g. Stardew Valley: exact title first, else the top store-search hit; check appName in the results).

## `maxReviewsPerApp` (type: `integer`):

Maximum reviews returned per game. Set 0 to get only game details.

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

recent = newest first, updated = recently updated first, all = most helpful first (supports day range).

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

Steam language code, e.g. all, english, german, french, spanish, schinese, russian, japanese, brazilian.

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

Only positive (recommended) or negative reviews, or both.

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

all, steam (bought on Steam) or non\_steam\_purchase (key activations).

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

With sort = Most helpful: only reviews from the last N days (max 365).

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

Add one free row per game (type = app) with name, developers, publishers, release date, price, genres, categories, platforms, Metacritic and review score summary.

## Actor input object example

```json
{
  "apps": [
    "730"
  ],
  "maxReviewsPerApp": 200,
  "filter": "recent",
  "language": "all",
  "reviewType": "all",
  "purchaseType": "all",
  "includeAppDetails": true
}
```

# 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 = {
    "apps": [
        "730"
    ]
};

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

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

```

## MCP server setup

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

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/r8TP6GdYRfndxzDdV/builds/NyJ13daDfpy3P1tTV/openapi.json