# Steam Game Reviews & Player Feedback Analyzer (`obliging_persimmon_cki/steam-game-feedback-analyzer`) Actor

Extract Steam reviews and turn player feedback into structured bug reports, feature requests, sentiment topics, performance complaints, and actionable game insights.

- **URL**: https://apify.com/obliging\_persimmon\_cki/steam-game-feedback-analyzer.md
- **Developed by:** [Dung Huynh](https://apify.com/obliging_persimmon_cki) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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/platform/actors/running/actors-in-store#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 Game Reviews & Player Feedback Analyzer

Collect public Steam reviews and turn player feedback into structured bug signals, feature requests, topics, sentiment, and game-level reports.

### What this Actor does

The Actor calls Steam’s public review and app-details endpoints, normalizes review metadata, preserves source-language labels, and optionally applies a deterministic English/Vietnamese feedback taxonomy. It separates raw collection from analysis so teams can export low-cost source data or receive structured product feedback in the same dataset.

Detected issues are reported player claims, not confirmed engineering bugs.

### Who it is for

- Indie developers and game studios
- Publishers, product managers, QA, and community teams
- Localization teams and Steam Deck support teams
- Game-market researchers and feedback analytics pipelines

### Key features

- Multiple Steam app IDs or Store/community URLs in one run
- Recent or bounded historical review collection with cursor pagination
- Positive, negative, purchase-type, date, and language filters
- Normalized review metadata with timestamps, votes, playtime, purchase, early-access, and Steam Deck signals
- English and Vietnamese analysis with language-neutral taxonomy IDs
- Bug, performance, stability, feature-request, controller, localization, multiplayer, and usability signals
- Actionability score and cautious severity estimate
- Duplicate issue clustering with stable IDs and review links
- One per-game aggregate report in the default key-value store
- Incremental output and partial-failure isolation

### Supported input

If neither `steamAppIds` nor `startUrls` is provided, the Actor uses Steam app 730 (Counter-Strike 2) as a safe smoke-test default. IDs from both sources are extracted, merged, and de-duplicated. The Console string-list editor represents app IDs as strings; the runtime also accepts numeric IDs.

```json
{
  "mode": "feedbackAnalysis",
  "steamAppIds": ["730"],
  "startUrls": [],
  "languages": ["english", "vietnamese"],
  "reviewFilter": "all",
  "purchaseType": "all",
  "dateRange": { "from": "", "to": "", "recentDays": 30 },
  "maxReviewsPerGame": 20,
  "includeReviewText": true,
  "analysis": {
    "enabled": true,
    "outputLanguage": "english",
    "clusterSimilarIssues": true
  },
  "aggregation": { "enabled": true },
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Use `recentDays: 0` to disable the recent-days bound. `from` and `to` are inclusive ISO date strings; blank strings omit those bounds.

### Modes

#### `rawReviews`

Collects normalized Steam review records without review-level analysis. This is the lowest-cost export mode.

#### `feedbackAnalysis`

Collects reviews and attaches validated feedback analysis, actionability, topics, issue/request details, and optional duplicate clusters. This is the default mode.

#### `patchImpact`

Compares bounded before/after review windows around a patch date. The report is stored under `GAME_<APP_ID>_PATCH_IMPACT_REPORT` and marks increased topics as possible regressions without making causal claims.

```json
{
  "mode": "patchImpact",
  "steamAppIds": ["730"],
  "languages": ["english"],
  "patch": {
    "releasedAt": "2026-07-20T00:00:00.000Z",
    "version": "1.4",
    "notesUrl": "https://example.com/patch-notes"
  },
  "daysBefore": 14,
  "daysAfter": 14,
  "maxReviewsPerPeriod": 100
}
```

### Output

Review and cluster records are pushed to the default dataset. Per-game reports are stored under `GAME_<APP_ID>_REPORT` in the default key-value store.

Example analyzed record:

```json
{
  "recordType": "review",
  "game": { "steamAppId": 730, "name": "Counter-Strike 2" },
  "review": {
    "reviewId": "1234567890",
    "language": "english",
    "text": "The game crashes when opening the inventory.",
    "recommended": false
  },
  "analysisStatus": "success",
  "analysis": {
    "isActionableFeedback": true,
    "actionabilityScore": 0.9,
    "primaryFeedbackType": "bugReport",
    "feedbackTypes": ["bugReport", "stabilityIssue"],
    "sentiment": "negative",
    "severity": "high",
    "topics": ["crashes", "inventory"],
    "summary": "The review reports a crash when opening the inventory.",
    "clusterId": "issue-730-bugreport-crash-when-opening-inventory"
  }
}
```

Example patch report fields include `topicChanges`, `newIssues`, `improvedTopics`, `possibleRegressions`, and an explicit non-causal disclaimer.

Example cluster record:

```json
{
  "recordType": "feedbackCluster",
  "clusterId": "issue-730-bugreport-crash-when-opening-inventory",
  "canonicalIssue": "Game crashes when opening the inventory",
  "feedbackType": "bugReport",
  "mentionCount": 47,
  "uniqueReviewCount": 47,
  "languages": ["english", "vietnamese"],
  "reviewIds": ["1234567890"]
}
```

### Output fields

| Field | Description |
| --- | --- |
| `recordType` | `review` or `feedbackCluster`. |
| `game.name` | Steam game name. |
| `game.steamAppId` | Numeric Steam app ID. |
| `review.language` | Language code returned by Steam. |
| `review.recommended` | Player recommendation flag. |
| `review.text` | Original review text, or `null` when disabled. |
| `analysisStatus` | `success` or `failed` when analysis is enabled. |
| `analysis.clusterId` | Stable link from a review to a duplicate-issue cluster. |
| `analysis.primaryFeedbackType` | Main taxonomy type. |
| `analysis.sentiment` | Positive, negative, mixed, or neutral. |
| `analysis.severity` | Estimated critical/high/medium/low/unknown severity. |
| `analysis.actionabilityScore` | Score from 0 to 1 for product-specific detail. |
| `analysis.topics` | Stable topic IDs such as `crashes`, `inventory`, or `steamDeck`. |
| `clusterId` | Stable ID on a `feedbackCluster` record. |
| `canonicalIssue` | Canonical issue title on a cluster record. |
| `feedbackType` | Primary feedback type represented by a cluster. |
| `mentionCount` | Number of source reviews represented by a cluster. |
| `source.scrapedAt` | Collection timestamp. |

### Feedback taxonomy

Primary feedback types include `bugReport`, `performanceIssue`, `stabilityIssue`, `featureRequest`, `balanceFeedback`, `difficultyFeedback`, `gameplayFeedback`, `contentRequest`, `usabilityIssue`, `accessibilityFeedback`, `localizationIssue`, `controllerIssue`, `steamDeckIssue`, `multiplayerIssue`, `serverIssue`, `matchmakingIssue`, `cheatingReport`, `monetizationFeedback`, `pricingFeedback`, `dlcFeedback`, `moddingFeedback`, `positiveFeedback`, `generalComplaint`, `nonActionable`, and `spamOrIrrelevant`.

Topics use stable IDs, including `crashes`, `freezes`, `stuttering`, `frameRate`, `loadingTime`, `disconnects`, `servers`, `matchmaking`, `saveSystem`, `combat`, `controls`, `controllerSupport`, `steamDeck`, `difficulty`, `balance`, `localization`, `subtitles`, `accessibility`, `userInterface`, `inventory`, `achievements`, `mods`, `antiCheat`, `coOp`, `pvp`, `earlyAccess`, `contentAmount`, and `replayability`.

Severity is an analytical estimate: `critical` indicates a possible launch/save/progression blocker, `high` indicates a major reported impact, `medium` indicates a meaningful but non-blocking issue, `low` indicates a minor issue or request, and `unknown` indicates insufficient context.

### Aggregated reports

When aggregation is enabled, one report per game is stored under `GAME_<APP_ID>_REPORT`. Reports contain review counts, analyzed/actionable counts, language distribution, top issues, feature requests, positive and negative topics, localization insights, and the review window. Report counts are calculated from the same records pushed to the dataset and remain valid when individual analyses fail.

### Language support

The collection layer accepts Steam language codes and preserves the code exactly as returned by Steam. The initial deterministic analysis taxonomy covers English and Vietnamese, while unknown or unsupported languages remain in the dataset with their original text and safe fallback classification. `sourceLanguage`, `analysisLanguage`, and `originalTextPreserved` make the normalization boundary explicit.

### Cost considerations

`rawReviews` avoids analysis work and is the lowest-cost mode. Analysis cost is bounded by `maxReviewsPerGame`, language filters, date filters, short-review handling, and duplicate review IDs. The current MVP uses a deterministic local analyzer and does not require a paid model provider; future provider-backed analysis must remain optional and preserve the same strict schema/fallback behavior.

This repository does not automatically publish the Actor or change pricing.

### Limitations

- Steam response formats, review availability, language tags, and rate limits can change.
- Steam language tags may not match the language of the text; the source tag is preserved rather than silently corrected.
- Reviews represent player opinions. Detected issues are not confirmed bugs, causes, regressions, or engineering priorities.
- Sarcasm, memes, very short reviews, mixed feedback, and unsupported languages can be misclassified.
- Cluster quality depends on topic and text similarity; review IDs are preserved for manual verification.
- The Actor does not scrape Reddit, Discord, esports data, price history, player-count predictions, sales estimates, patch notes, or media.

### Compliance and responsible use

The Actor processes public Steam review data only. It avoids reviewer names, avatars, profile URLs, social discovery, emails, and private account information; a public source ID may be retained solely for review provenance. Do not use the output to harass, profile, target, or identify individual reviewers. Respect Steam terms, robots/access policies, applicable privacy laws, and any downstream data-retention requirements.

### Benchmark results

See [`BENCHMARK_NOTES.md`](BENCHMARK_NOTES.md) for reproducible local Phase 0–6 results, the Phase 7 cloud smoke, and the Phase 8 automation-default regression smoke. Build `0.1.7` completed the empty game-selection cloud input with 5/5 successful analyses, 5 review records, zero errors, and a saved per-game report. The cloud smoke validates deployment and output wiring; it is not a human-labeled accuracy benchmark. Quality targets such as feedback-type accuracy and false bug-report rate require a reviewed sample before a production launch.

The Actor is published in Apify Store under the `GAMES` category. Pricing remains pay for usage.

### FAQ

#### Does this confirm bugs?

No. It extracts reported player feedback and estimates severity; engineering teams should reproduce and verify issues independently.

#### Can I export raw reviews only?

Yes. Set `mode` to `rawReviews` and `analysis.enabled` to `false`.

#### Can I request all languages?

Yes. Use `languages: ["all"]`. Preserve the returned language code and review text when evaluating unsupported languages.

#### Where are game reports stored?

In the default key-value store under `GAME_<APP_ID>_REPORT`.

#### Does it publish automatically?

No. Validation and deployment remain explicit operator actions.

### Roadmap

1. Add reviewed human-labeled quality benchmarks for English and Vietnamese.
2. Add optional provider-backed analysis behind the existing strict schema and fallback boundary.
3. Expand language-specific signals without creating separate Actors.

# Actor input Schema

## `mode` (type: `string`):

Collect raw reviews, attach deterministic analysis, or compare before/after review windows around a patch.

## `steamAppIds` (type: `array`):

One or more numeric Steam app IDs. Numeric strings are accepted by the runtime so the Console string-list editor can be used.

## `startUrls` (type: `array`):

Steam Store or community app URLs. App IDs are extracted and merged with steamAppIds.

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

Steam language codes. Use all to request all languages.

## `reviewFilter` (type: `string`):

Return all reviews or only positive/negative recommendations.

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

Filter reviews by whether the reviewer purchased the game on Steam.

## `dateRange` (type: `object`):

Optional inclusive date bounds and recent-days limit for review collection.

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

Hard cap on reviews collected for each Steam app.

## `includeReviewText` (type: `boolean`):

Keep the original public review text in each output record.

## `analysis` (type: `object`):

Settings reserved for the review-level analysis phase.

## `aggregation` (type: `object`):

Settings reserved for the per-game aggregation phase.

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

Optional Apify proxy settings for the collection layer.

## `debug` (type: `boolean`):

Emit additional diagnostic logs.

## `patch` (type: `object`):

Patch metadata for patchImpact mode.

## `daysBefore` (type: `integer`):

Number of days in the before window.

## `daysAfter` (type: `integer`):

Number of days in the after window.

## `maxReviewsPerPeriod` (type: `integer`):

Hard cap for each patch comparison window.

## Actor input object example

```json
{
  "mode": "feedbackAnalysis",
  "steamAppIds": [
    "730"
  ],
  "languages": [
    "all"
  ],
  "reviewFilter": "all",
  "purchaseType": "all",
  "maxReviewsPerGame": 100,
  "includeReviewText": true,
  "debug": false,
  "daysBefore": 14,
  "daysAfter": 14,
  "maxReviewsPerPeriod": 1000
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized raw Steam review records. When game selection is omitted, input normalization uses app 730; explicit app IDs and URLs remain unchanged. Later phases add analysis and feedback cluster records.

## `runStatistics` (type: `string`):

Machine-readable run counters and runtime summary.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("obliging_persimmon_cki/steam-game-feedback-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("obliging_persimmon_cki/steam-game-feedback-analyzer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call obliging_persimmon_cki/steam-game-feedback-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=obliging_persimmon_cki/steam-game-feedback-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qt4a4gDsEWW9KDmbE/builds/SUUx58Jps584lit1C/openapi.json