# Steam Review Scraper - Edits, Flips & Replies (`vdb997/steam-review-change-watch`) Actor

Monitor Steam player feedback with the current GetAppReviews API. Detect new reviews, recommendation flips, edited text and developer replies. Export playtime and review context; persistent history and flat pricing per game-language check.

- **URL**: https://apify.com/vdb997/steam-review-change-watch.md
- **Developed by:** [Victor Diaz](https://apify.com/vdb997) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 game-language checks

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 Scraper - Edits, Flips & Replies

Monitor new and edited Steam reviews with Valve's current **IUserReviewsService/GetAppReviews** API. Catch recommendation flips, text edits, developer replies and refund-flag changes without replaying unchanged reviews. Use the structured output for a game studio's feedback database, competitor research or an n8n/Make workflow.

### Who this is for

**Steam review monitoring for game studios.** Use the Steam review scraper to maintain a feedback database after releases and patches. Capture newly observed reviews, recommendation flips, text edits and developer replies from the recently updated review window. The window is capped and anonymous responses may be cached by Valve.

### Quick start

Export an immediate sample:

```json
{"appIds":["413150"],"language":"all","maxReviewsPerGame":100,"outputMode":"all"}
```

Monitor negative feedback on a schedule:

```json
{"appIds":["413150"],"language":"english","maxReviewsPerGame":500,"recommendationFilter":"negative","watchId":"game-feedback","outputMode":"changes"}
```

Changes mode establishes a silent baseline on the first successful run. Reuse the same Watch ID for later runs. Recommendations and minimum-playtime filters affect output only: a positive review excluded from output is still remembered, so its later negative recommendation can trigger an alert.

Steam store URLs such as `https://store.steampowered.com/app/413150/` also work. IDs are deduplicated. Up to 20 games per run; one explicit Steam language code per run. `all` requests every language together. Use separate runs and Watch IDs for distinct language monitoring projects.

### What is returned

`recordType=review` includes the review ID, game ID/name/type, game URL, review language and text, Steam's `recommended` boolean, created/updated timestamps, developer response, response time, refund/purchase/free-copy/early-access/Steam-Deck flags, playtime at review and current playtime (minutes), helpful/funny votes and comment count. `reviewUrl` links to the public source when Steam provides the author's ID. No player profiles are fetched, and no author-ID column is exported.

Change records add `changeType` (`baseline`, `new`, `changed`, `unchanged`), `changedFields`, `previousRecommended` and `observedAt`. Recommendation is Steam's explicit thumbs-up/down choice, not generated sentiment. Text, recommendation, language, developer response and context flags are compared. Vote counts, current playtime and timestamps alone do not produce change alerts.

A `check_summary` is always included per successful check. It reports coverage, duplicates, baseline/new/changed/unchanged counts, query rating totals and the positive share of this run's review sample. Query totals describe Steam's selected query; the sample share is **not** the game's store-wide rating. App metadata is read from the public US store; names are in English.

`source_error` records explain failed checks. `SUMMARY` in the default key-value store gives the whole run's status and spending-limit flag. A failure on any requested review page rejects the entire game check before history is updated or its custom event is charged.

### Pricing

**$0.05 per successful game-language check**, including app lookup and up to 500 most recently updated reviews, plus **$0.00005 per run start** at fixed 512 MB memory. Platform usage is included. There is no per-review or per-summary charge.

Empty or unchanged valid feeds still count. Failed source checks do not generate the game-language event; the standard start fee still applies. Five games cost $0.25005 per run, or $7.5015 for daily runs over 30 days. These are buyer costs, not creator earnings. Set Maximum cost per run to stop before starting checks beyond your budget.

### Scope and limits

- Uses the replacement GetAppReviews service, not the deprecated `/appreviews` endpoint. No Steam key, account, cookies or proxy required. Anonymous responses can be cached by Valve for up to ten minutes and have a lower rate limit; persistent 429/403 responses are reported as failures.
- Fixed sort: most recently **updated** reviews, all purchase types, all recommendations before output filters. Maximum 1–500 per game; default 100. This is a rolling window, not a complete archive. Newly observed IDs can be older reviews entering the window; missing IDs are not reported as deleted.
- `includeOffTopicReviews=true` requests off-topic activity too; false uses Valve's activity filter. This setting and the review cap affect the observed window.
- The store lookup must be publicly available in the US region. Unavailable IDs or malformed source data are errors, not paid empty successes. Game-name search, private discussions and review-comment bodies are not included.
- Cursor pages may change during a scan. Duplicates are removed; a missing or repeated cursor rejects an incomplete check. A bounded page budget prevents endless pagination.
- History stores IDs and comparison hashes for 90 days since last observation, up to 20,000 IDs per game-language. Full historical review bodies are not stored in the watch store. Snapshots stay in the caller's Apify account. Use non-overlapping schedules with the same Watch ID.
- This independent Actor is not affiliated with Valve or Steam. Public review text remains third-party content; follow the source's terms when reusing it.

Source: [Valve's current review API documentation](https://partner.steamgames.com/doc/webapi/IUserReviewsService) and the public Steam store app-details endpoint.

Related tools: [App Store Review Watch](https://apify.com/vdb997/app-store-review-watch), [Sitemap Growth Watch](https://apify.com/vdb997/sitemap-growth-watch), [Shopify Price & Restock Watch](https://apify.com/vdb997/shopify-price-restock-watch).

### Try one source before scheduling

1. Open the Input tab and use one supported source with `outputMode: "all"` for an immediate export.
2. Check the returned records and the check summary. Confirm the source, coverage and price suit your workflow.
3. To monitor, set a stable Watch ID and `outputMode: "changes"`. The first successful run establishes a silent baseline.
4. Reuse that Watch ID on later runs. A summary without change records means the check completed without matching changes.
5. Add an Apify schedule after the manual checks work. Avoid overlapping runs with the same Watch ID. Use Maximum cost per run to cap event charges.

Public-data monitors by the same developer: [browse the catalog](https://apify.com/vdb997).

# Actor input Schema

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

Numeric Steam app IDs or https://store.steampowered.com/app/... URLs. No game-name search or API key required.

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

Steam language code. Each game in this language is one paid check; all combines every language.

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

Most recently updated reviews. This is a rolling window, not a full archive.

## `recommendationFilter` (type: `string`):

Output-only filter: all scanned reviews are remembered, so a positive-to-negative edit can still be detected.

## `minPlaytimeAtReviewMinutes` (type: `integer`):

Output-only filter. Uses playtime when the review was written, not current playtime.

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

Pass false to request Steam's off-topic activity filter. This does not generate sentiment classifications.

## `watchId` (type: `string`):

Reuse an ID for history in your account. A new ID resets history. Do not overlap runs with the same ID.

## `outputMode` (type: `string`):

Changes mode begins with a silent baseline; check summaries and source errors are always returned.

## Actor input object example

```json
{
  "appIds": [
    "413150"
  ],
  "language": "all",
  "maxReviewsPerGame": 100,
  "recommendationFilter": "all",
  "minPlaytimeAtReviewMinutes": 0,
  "includeOffTopicReviews": true,
  "outputMode": "all"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "appIds": [
        "413150"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vdb997/steam-review-change-watch").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": ["413150"] }

# Run the Actor and wait for it to finish
run = client.actor("vdb997/steam-review-change-watch").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": [
    "413150"
  ]
}' |
apify call vdb997/steam-review-change-watch --silent --output-dataset

```

## MCP server setup

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

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/ggYLSvfxiS1seI4Dw/builds/LeiZJbsFyxLdnXYkj/openapi.json