Steam Review Monitor & Player Feedback Alerts

Monitor genuinely new Steam reviews without paying for the same feedback again

Track public Steam player reviews across one or more games and receive only reviews that have not already been seen in that monitored game × language dimension.

This Actor keeps persistent state keyed by Steam recommendationid. The first successful run for a dimension creates a free baseline; later runs emit NEW_REVIEW only for genuinely unseen review IDs.

It also provides native Steam review-score description changes and per-game review velocity summaries for free.

No login. No Steam API key. No browser automation. No LLM in runtime.

Key features

• Stateful Steam review monitoring
• Persistent deduplication by recommendationid
• Free first-run baseline per game × language
• Only genuinely unseen reviews are billable
• Full public review text
• Thumbs up/down recommendation
• Author playtime
• Steam purchase flag
• Received-for-free flag
• Refunded flag
• Early Access flag
• Steam Deck flag
• Votes up and funny votes
• Review creation and update timestamps
• Native Steam review-score description changes
• Native positive/negative/total review counts
• Review velocity over the fetched 24-hour window
• Language-specific monitoring dimensions
• Up to 50 game × language dimensions per run
• Controlled request pacing and retries
• Free per-dimension summaries
• Free RUN_SUMMARY
• Pay Per Event

Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam. Data comes from the public Steam Store appreviews endpoint and remains subject to Steam's public source behavior and policies.

---

What this Actor is for

A normal review scraper returns a current page of reviews.

A monitor should answer a different question:

Which player reviews appeared since I last checked?

This Actor remembers the review IDs already observed for each monitored dimension.

That makes it useful for:

• game launch monitoring;
• player-feedback pipelines;
• live-ops monitoring;
• publisher portfolio monitoring;
• competitor research;
• community and product research;
• QA feedback collection;
• recurring review dashboards;
• Slack or webhook alerts;
• database and BI pipelines.

---

Important: the first run is a free baseline

The first successful observation of each:

game × language

dimension learns the current recent review IDs.

It does not emit those existing reviews as new.

Example:

First run:
100 recent reviews fetched
100 IDs remembered
0 NEW_REVIEW records

If 8 unseen reviews later enter the recent feed:

Next run:
8 unseen recommendation IDs
8 NEW_REVIEW records

This prevents historical recent reviews from being presented as new activity.

---

Important: edited reviews are not re-billed

Steam keeps the same:

recommendationid

when a player edits an existing review.

The Actor deduplicates by that ID.

Therefore:

same recommendationid
+
different timestamp_updated
=
already seen

An edit does not become another billable NEW_REVIEW.

---

Who it's for

Game studios

Monitor player feedback during:

• launches;
• patches;
• DLC releases;
• events;
• major balance changes.

Publishers

Track review flow across a portfolio while keeping each title and language in its own monitoring dimension.

Community and product teams

Route new player feedback into:

• Slack;
• internal dashboards;
• issue-triage queues;
• spreadsheets;
• research databases.

Competitive research teams

Watch public reviews for competing titles without repeatedly re-exporting the same recent review IDs.

Automation builders

Connect results to:

• Apify webhooks;
• n8n;
• Make;
• Zapier;
• Google Sheets;
• Slack;
• databases;
• BI tools;
• custom applications;
• AI analysis downstream.

The Actor itself does not perform AI sentiment analysis.

---

How it works

For every game × language dimension, the Actor:

1. validates the Steam app ID;
2. fetches recent public reviews from Steam;
3. follows Steam cursors up to maxReviewsPerQuery;
4. normalizes review fields;
5. loads persistent state for that dimension;
6. compares each recommendationid with the seen-ID set;
7. emits only unseen reviews after the baseline run;
8. remembers the fetched IDs in bounded persistent state;
9. compares Steam's native review_score_desc with the previous value;
10. writes a free score-change record when that native description changes;
11. calculates review velocity from fetched reviews created within the previous 24 hours;
12. writes a free APP_REVIEW_SUMMARY;
13. writes a free RUN_SUMMARY;
14. keeps operational diagnostics in STATS.

---

Data source

The Actor uses the public Steam Store endpoint:

https://store.steampowered.com/appreviews/<APP_ID>

with JSON output enabled.

The implementation requests:

filter=recent
purchase_type=all

and a configured review language.

No authenticated Steam session is used.

---

Input

Recommended example

{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    },
    {
      "appId": 730,
      "label": "Counter-Strike 2"
    }
  ],
  "languages": [
    "english"
  ],
  "maxReviewsPerQuery": 200,
  "maxResults": 500,
  "maxRuntimeMs": 300000
}

Input fields

Field	Default	Description
apps	required	Steam app IDs or { appId, label } objects.
languages	["english"]	Steam review-language dimensions. Empty means all languages in one dimension.
maxReviewsPerQuery	100	Recent reviews read per dimension. Range: 20–500.
maxResults	500	Maximum billable NEW_REVIEW records. Range: 1–5,000.
maxRuntimeMs	300000	Hard runtime cap in milliseconds.
debug	false	Additional diagnostic logging.

---

How to find the Steam app ID

The app ID appears in the public Store URL.

Example:

https://store.steampowered.com/app/570/Dota_2/

App ID:

570

You can provide a bare numeric app ID:

{
  "apps": [
    570
  ]
}

or add a label:

{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ]
}

---

Language dimensions

Each language creates an independent monitoring dimension.

Example:

{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ],
  "languages": [
    "english",
    "brazilian"
  ]
}

This creates:

570/english
570/brazilian

with independent state.

Common Steam language codes include:

english
brazilian
german
french
spanish
schinese
tchinese
japanese
koreana
russian

All languages

Use:

{
  "languages": []
}

to monitor all languages as one dimension.

The revised input validation also rejects combining:

all

with specific languages in the same run, because those feeds overlap and could surface the same review in more than one monitored dimension.

---

Dimension cap

The Actor enforces:

apps × languages <= 50

When languages is empty, all languages count as one dimension per app.

Examples:

10 games × 1 language = 10 dimensions
10 games × 3 languages = 30 dimensions
20 games × 3 languages = 60 dimensions → invalid

Split larger portfolios across separate Tasks or schedules.

---

Recent-review window

The Actor does not download full historical review archives.

It reads Steam's:

recent

review feed up to:

maxReviewsPerQuery

per dimension.

This is the core operational rule:

Your read window should be larger than the number of new reviews expected between scheduled runs.

For a quiet game, 100 may be more than enough.

For a launch or viral title, use:

• a larger maxReviewsPerQuery;
• a shorter schedule interval;
• or both.

---

Important high-volume limitation

The current maximum is:

500

recent reviews per dimension per run.

If more than 500 new reviews arrive between two runs, older unseen reviews can fall beyond the Actor's recent-feed read window before they are observed.

Persistent deduplication prevents duplicates.

It cannot recover reviews that were never fetched.

For very high-volume launch periods, schedule the Actor more frequently.

---

Output

The default dataset can contain four record types:

NEW_REVIEW
REVIEW_SCORE_CHANGE
APP_REVIEW_SUMMARY
RUN_SUMMARY

---

NEW_REVIEW

This is the billable player-feedback event.

It is emitted only when:

• the dimension is past its first successful baseline;
• the review has a valid recommendationid;
• that ID is not already in persistent state;
• the record is admitted by result/runtime/billing caps.

Example

{
  "recordType": "NEW_REVIEW",
  "entityId": "listening:steam:570/233081975",
  "source": "steam",
  "appId": 570,
  "appLabel": "Dota 2",
  "dimensionLanguage": "english",
  "recommendationId": "233081975",
  "language": "english",
  "review": "You can't get enough of it",
  "createdAt": "2026-08-17T22:26:26.000Z",
  "updatedAt": "2026-08-17T22:26:26.000Z",
  "votedUp": true,
  "votesUp": 0,
  "votesFunny": 0,
  "weightedVoteScore": 0.5,
  "steamPurchase": true,
  "receivedForFree": false,
  "refunded": false,
  "earlyAccess": false,
  "steamDeck": false,
  "authorSteamId": "76561198328512937",
  "playtimeForeverMin": 372004,
  "authorNumReviews": 2,
  "observedAt": "2026-08-18T00:00:00.000Z"
}

---

NEW_REVIEW fields

Field	Description
recordType	NEW_REVIEW.
entityId	Stable review identity based on app ID and recommendation ID.
source	steam.
appId	Steam app ID.
appLabel	User-provided game label.
dimensionLanguage	Monitored language dimension.
recommendationId	Steam review identity used for persistent deduplication.
language	Review language returned by Steam.
review	Public review text.
createdAt	Review creation time.
updatedAt	Review update time.
votedUp	Player recommendation direction.
votesUp	Helpful votes when provided.
votesFunny	Funny votes when provided.
weightedVoteScore	Steam-provided weighted vote score when available.
steamPurchase	Whether Steam marks it as a Steam purchase.
receivedForFree	Whether Steam marks the product as received for free.
refunded	Refund flag when returned.
earlyAccess	Whether written during Early Access.
steamDeck	Steam Deck primary-use flag when returned.
authorSteamId	Public author Steam ID when available.
playtimeForeverMin	Author lifetime playtime in minutes when available.
authorNumReviews	Author review count when available.
observedAt	Actor observation timestamp.

---

REVIEW_SCORE_CHANGE

This record is free.

It appears only after a baseline exists and Steam's native:

review_score_desc

changes between observations.

Example:

Mostly Positive
→
Very Positive

The Actor does not calculate its own review-score category.

It stores:

previousScoreDesc
currentScoreDesc
native

where native is the Steam query_summary projection.

---

Native Steam score block

The free score summary can include:

reviewScore
reviewScoreDesc
totalPositive
totalNegative
totalReviews

These values come directly from Steam's response.

They are not reconstructed from only the fetched recent page.

---

APP_REVIEW_SUMMARY

Every successfully processed dimension gets a free summary.

It can include:

appId
appLabel
dimensionLanguage
baseline
reviewsFetched
newReviews
reviewsDelivered
seenBefore
skippedNoId
velocityPer24h
scoreNative
observedAt

Velocity meaning

velocityPer24h counts the fetched review records whose creation timestamp falls within the previous 24 hours.

It is not guaranteed to equal every review Steam received in the last 24 hours when your maxReviewsPerQuery window is smaller than that volume.

---

RUN_SUMMARY

The final run summary is free.

It can include:

billableRecords
freeRecords
baselineDimensions
scoreChanges
httpRequests
http429
httpRetries
capReason
qualityAlert
sourceUnavailable
warnings
units
cost
pricingLabel

This makes a quiet run visible even when no new review is billable.

---

Persistent state

Each game × language dimension stores a bounded list of recent seen review IDs.

The current state cap is:

10,000 recommendation IDs

per dimension.

For normal monitoring this provides a long dedup horizon.

Extremely high-volume dimensions can eventually age old IDs out of bounded state.

Because the Actor reads only the recent feed, IDs that have fallen far outside the recent source window normally do not reappear.

---

Request pacing and retries

The Steam client enforces a minimum spacing of:

2 seconds

between requests.

Retryable conditions use a controlled backoff ladder:

30 seconds
60 seconds
120 seconds

with jitter.

The Actor handles:

• HTTP 429;
• applicable 5xx responses;
• network failures;
• timeouts;
• unexpected source shape.

It does not attempt to bypass Steam access controls.

---

Scheduling

This Actor is intended for recurring execution.

A practical starting point:

daily

for normal games.

During launches or high-volume events, consider:

hourly

or another interval appropriate to expected review volume.

Remember:

expected new reviews between runs
<
maxReviewsPerQuery

is the condition you want for reliable novelty capture.

---

Recommended scheduled workflow

1. Add games and review languages.
2. Run once to create the free baseline.
3. Save the input as an Apify Task.
4. Open Schedules.
5. Choose the monitoring cadence.
6. Send future NEW_REVIEW records downstream.

Possible destinations:

• Slack;
• Discord;
• Teams;
• email workflows;
• Google Sheets;
• n8n;
• Make;
• databases;
• dashboards;
• ticketing or feedback systems.

---

Example launch-monitoring input

{
  "apps": [
    {
      "appId": 123456,
      "label": "My Game"
    }
  ],
  "languages": [
    "english",
    "brazilian"
  ],
  "maxReviewsPerQuery": 500,
  "maxResults": 1000,
  "maxRuntimeMs": 300000
}

A downstream workflow can then:

• send new negative/positive reviews to a feedback channel;
• create a support or QA triage item;
• save review text to a research database;
• compare feedback by language;
• summarize batches downstream with AI;
• track Steam's native review-score description.

---

API

Run the Actor through the Apify API:

curl -s "https://api.apify.com/v2/acts/<YOUR_USERNAME>~steam-review-monitor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "apps":[{"appId":570,"label":"Dota 2"}],
    "languages":["english"],
    "maxReviewsPerQuery":200,
    "maxResults":500
  }'

Replace:

<YOUR_USERNAME>
<YOUR_APIFY_TOKEN>

with your Apify account values.

---

Integrations

Use with:

• Apify API;
• Tasks;
• Schedules;
• webhooks;
• n8n;
• Make;
• Google Sheets;
• Slack;
• Discord;
• Teams;
• databases;
• BI tools;
• internal applications;
• AI agents downstream.

---

Pricing

This Actor uses Pay Per Event.

The code uses two custom billing events:

actor-start
new-review

actor-start

Called once after valid input has been accepted.

Invalid input is rejected before the billing gate opens.

new-review

Charged once for each delivered NEW_REVIEW.

The Actor does not charge new-review for:

• baseline review IDs;
• already-seen review IDs;
• edited reviews with the same recommendation ID;
• REVIEW_SCORE_CHANGE;
• APP_REVIEW_SUMMARY;
• RUN_SUMMARY.

The Pricing tab on the Actor page is always the authoritative source for current prices.

---

What is free

Free by design:

first baseline
edited reviews
already-seen reviews
REVIEW_SCORE_CHANGE
APP_REVIEW_SUMMARY
RUN_SUMMARY

A quiet scheduled run therefore does not create a new-review charge.

The configured start event can still apply.

---

Cost control

The primary controls are:

apps
languages
maxReviewsPerQuery
maxResults
maxRuntimeMs

Lower-volume monitoring

Use:

• fewer dimensions;
• a lower review-read cap when the source volume is safely below it;
• a reasonable schedule.

Launch monitoring

Use:

• shorter schedule intervals;
• maxReviewsPerQuery closer to 500;
• language-specific dimensions when needed.

---

Run health

Operational statistics are written to:

STATS

in the default Key-Value Store.

Depending on the run, they can include:

• HTTP requests;
• retries;
• 429 responses;
• dimensions completed;
• dimensions failed;
• baseline dimensions;
• billable records;
• free records;
• score changes;
• source availability;
• quality warnings;
• runtime;
• cost metrics.

---

Honest limits

Recent-feed monitor, not a full-history exporter

The Actor reads Steam's recent review feed.

It is not designed to download every historical review ever written.

Maximum 500 reviews per dimension per run

If more new reviews arrive between runs than the read window can contain, unseen older reviews can be missed.

Schedule high-volume games more frequently.

Game × language state is independent

The same app monitored in different language dimensions has separate state.

Avoid overlapping aggregate and language-specific feeds in the same run.

The revised validator blocks all plus specific language codes.

Review edits are intentionally not emitted

An edited review keeps its recommendation ID and remains already seen.

This Actor is a new-review monitor, not an edit-history monitor.

Score-change records use Steam's native category

The Actor does not create its own sentiment score.

Velocity is based on the fetched window

velocityPer24h counts qualifying fetched reviews, not necessarily the full 24-hour Steam volume when the read window is truncated.

No comment-thread or forum monitoring

The Actor does not monitor:

• Steam Community discussions;
• comments on reviews;
• forums;
• guides;
• workshop content.

No AI sentiment analysis

votedUp is the player's own Steam recommendation flag.

The Actor does not infer sentiment from review text.

Public source behavior can change

Steam can change rate limits, fields, or endpoint behavior.

The Actor includes retries, source-shape checks, and health signals to surface problems instead of inventing records.

---

FAQ

Do I need a Steam account?

No.

Do I need a Steam API key?

No.

Does it use a browser?

No.

What happens on the first run?

The current recent review IDs are learned as a free baseline.

No historical recent review is emitted as NEW_REVIEW.

Why did I receive no billable reviews?

Possible reasons:

• this was the baseline;
• no unseen review ID appeared;
• the result cap stopped further delivery.

If a player edits a review, am I charged again?

No.

Deduplication uses recommendationid.

Can I monitor multiple games?

Yes.

The combined game × language dimension count must be 50 or less.

Can I monitor Portuguese reviews?

Yes.

Steam commonly uses:

brazilian

for Brazilian Portuguese reviews.

Can I monitor all languages?

Yes.

Use:

{
  "languages": []
}

Can I combine all languages and English?

Not in the revised input validation.

That would create overlapping feeds and is rejected.

Does it tell me whether the review is positive?

The source field:

votedUp

is preserved.

Does it return review text?

Yes.

Does it return player playtime?

Yes, when Steam provides it.

The field is:

playtimeForeverMin

Does it show refunds or free copies?

The output can include:

refunded
receivedForFree
steamPurchase

when returned by Steam.

What is a review-score change?

A free record produced when Steam's native:

review_score_desc

changes from the value stored on the previous run.

Can I schedule this Actor?

Yes.

Are score changes charged?

No.

Are summaries charged?

No.

What am I charged for?

The custom start event shown in Pricing plus genuinely unseen NEW_REVIEW records delivered after baseline.

Is this affiliated with Steam or Valve?

No.

This is an independent community Actor using public Steam Store review data.

---

Support

For bugs, questions, or requested fields:

johnatan291303@gmail.com

You can also use the Issues tab on the Actor page.

---

Part of the JM Forge suite

Also from the same developer:

• Steam Game Price, Discount & Review Monitor — monitor price, discount, catalog, and native review-count changes.
• NHTSA Recall, Complaint & Safety Spike Monitor — stateful US vehicle-safety monitoring.
• ATS Salary, Skills & Seniority Intelligence — structured hiring intelligence from public ATS boards.

JM Forge Actors remain independent tools.

Use this Actor for player-review novelty and feedback monitoring.

Use the Steam game-data monitor for catalog, pricing, and aggregate game metrics.