# Steam Reviews Scraper + AI Analysis (No Login) (`pappy-dev/steam-review-intelligence`) Actor

Scrape unlimited Steam reviews for any game by App ID via Valve's official public API — no login, no proxy needed. On top of raw reviews you get optional AI analyses: review bombs timeline, playtime segments, pain points, feature requests, and a headline summary.

- **URL**: https://apify.com/pappy-dev/steam-review-intelligence.md
- **Developed by:** [Backyard Tools](https://apify.com/pappy-dev) (community)
- **Categories:** Agents, MCP servers, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.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?

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 + AI Analysis (No Login)

Scrape unlimited Steam reviews for any game by App ID via Valve's official public API — no login, no proxy needed. On top of raw reviews you get optional AI analyses: review bombs timeline, playtime segments, pain points, feature requests, and a headline summary.

Most Steam scrapers hand you raw rows. This one ships the analysis you were going to build anyway: review-bomb detection, playtime-segment sentiment, complaint themes — computed deterministically, no LLM tax.

***

### Review bombs — the part nobody else does

Every studio eventually asks *"what happened in that week?"* This actor answers it directly, with the receipts:

```json
{
  "window": "2024-05",
  "reviews": 2529,
  "negativeShare": 0.953,
  "deltaVsBaseline": 0.21,
  "negativeLanguages": [
    { "language": "english", "reviews": 2049 },
    { "language": "german", "reviews": 84 }
  ],
  "exampleReview": "With today's announcement that Take-Two has laid off the entirety of Intercept Games…"
}
```

That's real output (Kerbal Space Program 2, 31,874 reviews). The detector flagged the exact month the studio-layoff news broke, quoted the top-voted review from that window, and showed the bomb was English-speaking — not a regional pile-on.

Detection is statistical, not vibes: a window counts as a bomb only when its negative share beats the game's lifetime baseline by 10+ points **at the Wilson lower bound**, so a loud week with 12 reviews can't fake it. You also get the full month-by-month (or week-by-week) timeline to chart.

Valve hides reviews from periods it marked as off-topic review activity. Turn on `includeOffTopicReviews` to analyse those too.

### Playtime segments — who exactly is unhappy

Steam reviews carry hours-played at review time. The actor splits sentiment by segment:

| Segment | What it tells you |
|---|---|
| under 2h (refund window) | Your first impression — these reviewers can still refund |
| 2–10h / 10–50h / 50–200h | The mid-game |
| 200h+ | Your veterans |

Plus `received for free` vs `paid`, and `early access` vs `after release` splits. If newcomers sit at 45% positive while veterans sit at 89%, you have an onboarding problem, not a content problem — and now you can prove it.

### No count cap

Apple caps its public feed at 200 reviews per storefront. Steam doesn't: this actor walks the cursor feed from newest to oldest until your limit, your `sinceDate`, or the end.

Measured: **31,874 of a game's 31,876 total reviews in one run** (the feed itself withholds a couple), zero duplicates. `sinceDate` stops collection early — reviews arrive newest-first — so weekly incremental pulls stay small and cheap.

### Analyses

Each is billed **once per run**, not per review.

| Analysis | What you get |
|---|---|
| `reviewBombs` | Per-window timeline, flagged bomb windows with language mix and a top-voted example quote |
| `playtimeSegments` | Sentiment by hours-played, newcomers-vs-veterans verdict, free-vs-paid and EA-vs-release splits |
| `painPoints` | What negative reviewers actually complain about, scored by lift vs the full corpus, with example quotes |
| `featureRequests` | What players ask for, extracted from request-language reviews |
| `summary` | Headline numbers incl. store-wide totals and score label straight from Steam |

Analysis is **deterministic** — no LLM in the loop. Same input, same output, every time. No hallucinated themes, no per-token cost passed on to you.

### Use Cases

- **Review-bomb crisis triage**: catch a bomb the day it starts with the Wilson-bound-flagged window and a top-voted quote — the receipts you need before responding publicly.
- **Onboarding vs. veteran diagnosis**: split sentiment by playtime segment to see whether under-2h newcomers or 200h+ veterans are the unhappy ones — a different fix either way.
- **Giveaway / bundle impact check**: compare `received for free` vs `paid` reviewers to see whether a promo shifted your review average up or down.
- **Feature roadmap input**: mine `featureRequests` for what players are actually asking for, in their own words.

### Steam reviews scraper — input

```json
{
  "appIds": ["954850"],
  "maxReviewsPerApp": 50000,
  "languages": ["all"],
  "sinceDate": "2026-01-01",
  "includeOffTopicReviews": true,
  "aiAnalysis": ["reviewBombs", "playtimeSegments", "painPoints"]
}
```

`appIds` accepts numeric IDs **or** full store URLs. No IDs handy? Pass `searchTerm` instead and the actor resolves it.

### Steam reviews scraper — output fields

Reviews (`type: "review"`), one dataset item each:

| Field | |
|---|---|
| `appId` `appName` `language` | which game, which language |
| `review` `votedUp` `timestampCreated` | the review |
| `playtimeAtReviewHours` `playtimeForeverHours` | hours played at review / now |
| `steamPurchase` `receivedForFree` `refunded` `earlyAccess` `steamDeck` | context flags |
| `votesUp` `votesFunny` `weightedVoteScore` `authorName` `url` | metadata |

Analyses arrive as separate items with `type: "analysis"`.

### Pricing

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Per review | **$0.0002** ($0.20 per 1,000) |
| Per analysis | **$0.05** (`summary`: $0.03) |

The full 31,874-review history above with all five analyses: about **$6.60**. A weekly 1,000-review incremental pull with two analyses: about **$0.30**.

**Budget-aware:** if your run's *Max total charge (USD)* can't cover both the reviews and the analyses you selected, the actor collects fewer reviews instead of starving the analyses. Measured: a $0.50-capped run collected 1,348 reviews and still delivered all five analyses — the run completes instead of aborting mid-way.

### Why this one won't rot

It reads the same public review endpoint Steam's own store pages use — documented by Valve at partner.steamgames.com. No login, no headless browser, no proxy rotation, no CAPTCHA arms race. Nothing to break when a site ships a redesign.

No personal data beyond what Steam already publishes: reviewer names are public display names, and the actor adds nothing on top.

### Notes

- Some pages legitimately return fewer than 100 reviews mid-stream — that's Steam's language-shard merging, not the end of the feed. The actor keeps walking the cursor; it stops only on an empty page or a repeated cursor.
- `languages: ["all"]` is the honest default for bomb analysis — bombs are often concentrated in one language, and filtering it out hides the story.

***

Built by Backyard Tools.

# Actor input Schema

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

Numeric Steam app IDs or full store URLs. Example: 367520 or https://store.steampowered.com/app/367520/Hollow\_Knight/

## `searchTerm` (type: `string`):

Used only when App IDs is empty.

## `searchLimit` (type: `integer`):

When resolving games from searchTerm, how many of the top search hits to process.

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

Steam's feed has no page cap — reviews are collected newest-first until this limit, the sinceDate cutoff, or the end of the feed.

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

Steam language codes (english, japanese, schinese, german, …) or \["all"]. Review bombs often happen in one language, so "all" is the honest default for analysis.

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

Server-side filter on thumbs up / thumbs down.

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

Steam distinguishes reviews from Steam purchases and key activations.

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

ISO date, e.g. 2026-01-01. Reviews arrive newest-first, so collection stops early once this date is reached — efficient incremental pulls.

## `includeOffTopicReviews` (type: `boolean`):

Valve hides reviews from periods it marked as "off-topic review activity" (review bombs) by default. Turn this on to include them — recommended when running the review-bomb analysis.

## `aiAnalysis` (type: `array`):

Each selected analysis is charged once per run, regardless of review count.

## `throttleSeconds` (type: `integer`):

0 uses the safe default (0.3 s). Raise it only if you see gaps in long pulls.

## Actor input object example

```json
{
  "appIds": [
    "367520"
  ],
  "searchLimit": 1,
  "maxReviewsPerApp": 1000,
  "languages": [
    "all"
  ],
  "reviewType": "all",
  "purchaseType": "all",
  "includeOffTopicReviews": false,
  "aiAnalysis": [],
  "throttleSeconds": 0
}
```

# 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": [
        "367520"
    ],
    "languages": [
        "all"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pappy-dev/steam-review-intelligence").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": ["367520"],
    "languages": ["all"],
}

# Run the Actor and wait for it to finish
run = client.actor("pappy-dev/steam-review-intelligence").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": [
    "367520"
  ],
  "languages": [
    "all"
  ]
}' |
apify call pappy-dev/steam-review-intelligence --silent --output-dataset

```

## MCP server setup

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

```

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/GCuVKATTUrhegEgSo/builds/dVDCBaXdGigv8kKsY/openapi.json