Steam Game Price, Discount & Review Monitor

Monitor Steam game prices, discounts, release status, and review changes

Track up to 200 Steam app IDs or Store URLs per run and receive either:

• change-only monitoring events, or
• full normalized game details.

The Actor reads Steam's public storefront endpoints and can monitor signals such as:

• price changes;
• discount starts;
• discount ends;
• a game moving from coming soon to released;
• review-score changes;
• review-count changes above your chosen threshold.

The first healthy monitor run for each app + country creates a free baseline. Later runs compare the current storefront data with that saved state and write only the selected changes.

Every monitor run also writes one free:

BATCH_SUMMARY

record, so a successful run with no changes still produces a clear monitoring result.

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

Key features

• Monitor up to 200 Steam games per run
• Accept Steam app IDs or Store URLs
• Regional pricing through countryCode
• Price-change events
• Discount-start events
• Discount-end events
• Released-state events
• Review-score change events
• Review-count delta events
• Configurable minimum review delta
• Free first-run baseline per app + country
• Free BATCH_SUMMARY on every monitor run
• One-shot full details mode
• Persistent diff state
• Per-app status and diagnostics
• Rate-limit aware request pacing
• Result-cap state protection
• Schedule-ready for daily competitive monitoring
• Pay only for written change events or detail records

Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam. Data comes from Steam's public storefront endpoints and remains subject to Steam's applicable terms and policies.

---

What this Actor is for

This Actor is designed for recurring game-market monitoring rather than just one-time scraping.

Use it to answer questions such as:

Which games in my competitive set changed price today?

Which competitor just started or ended a discount?

Which monitored games accumulated a meaningful number of new reviews since the last run?

Which coming-soon titles are now released?

You can also switch to details mode when you want a one-time normalized export of the currently available Steam Store metadata.

---

Who it's for

Indie developers and publishers

Monitor a defined competitive set and detect:

• competitor price changes;
• discount launches;
• discount endings;
• release-state changes;
• changes in review totals.

Route those events to Slack, Sheets, a database, or your own internal tooling.

Game-market analysts

Build recurring datasets around:

• regional pricing;
• discounts;
• review totals;
• review score;
• release status;
• developers and publishers;
• genres;
• platforms;
• Metacritic;
• recommendations.

Deal and wishlist tools

Consume structured events such as:

PRICE_CHANGE
DISCOUNT_START
DISCOUNT_END

without maintaining your own Steam storefront monitor.

Competitive-intelligence teams

Track a portfolio of games and retain only meaningful changes rather than storing an identical full record every day.

---

Important: review deltas are signals, not sales figures

The Actor can monitor changes in total review counts.

A:

REVIEW_DELTA

event can be useful as a momentum or engagement signal.

However, review growth is not exact unit-sales data.

Do not interpret:

reviewsDelta

as an exact number of copies sold.

If you use review growth as a market proxy, apply your own analytical assumptions downstream.

---

Two operating modes

The Actor supports:

monitor
details

---

Monitor mode

monitor is the default mode.

It stores state per:

appid + countryCode

This is important because Steam pricing can vary by region.

Changing the pricing country therefore does not compare one regional price directly against a baseline from another country.

First healthy run

The first healthy monitor run for an app + country creates a baseline.

The baseline is free and does not pretend that the game's current price, discount, review total, or other state is a new event.

A per-app status can report:

BASELINE_CREATED

Every monitor run also writes the free:

BATCH_SUMMARY

record.

Later runs

Later healthy runs compare current Steam storefront data against the saved state.

Selected differences are written as:

CHANGE_EVENT

records.

---

Supported change events

The Actor supports these six event types:

PRICE_CHANGE
DISCOUNT_START
DISCOUNT_END
RELEASED
REVIEW_SCORE_CHANGE
REVIEW_DELTA

PRICE_CHANGE

Emitted when the monitored final price changes between healthy states.

DISCOUNT_START

Emitted when a discount appears after the previous healthy state had no discount.

DISCOUNT_END

Emitted when an active discount ends.

RELEASED

Emitted when the monitored Steam release state changes from coming soon to released.

REVIEW_SCORE_CHANGE

Emitted when the storefront review score changes.

REVIEW_DELTA

Emitted when the total review count changes by at least:

minReviewDelta

The event can include:

reviewsDelta
positiveDelta
negativeDelta

---

Details mode

Use:

{
  "mode": "details"
}

for a one-time full export.

Instead of diff events, the Actor writes one rich normalized detail record per successfully processed app.

The documented detail dataset can include current fields such as:

• app ID;
• game name;
• Store URL;
• regional price;
• discount;
• free-game status;
• release information;
• developers;
• publishers;
• genres;
• supported platforms;
• Metacritic data;
• recommendation data;
• review score;
• review totals.

Use details mode for:

• portfolio exports;
• market research;
• game metadata enrichment;
• dashboards;
• one-time competitor analysis.

---

Input

Daily competitive monitoring example

{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "minReviewDelta": 10
}

Input fields

Field	Type	Default	Description
appids	array	required	1–200 Steam app IDs or Store URLs.
mode	string	monitor	monitor for change events + free summary, or details for full one-time exports.
countryCode	string	us	Steam pricing region. Monitor state is stored per app + country.
eventTypes	array	all 6	Select any subset of PRICE_CHANGE, DISCOUNT_START, DISCOUNT_END, RELEASED, REVIEW_SCORE_CHANGE, REVIEW_DELTA.
minReviewDelta	integer	10	Minimum total-review change required for a REVIEW_DELTA event.
maxResults	integer	5000	Hard cap on charged records. A truncated app's diff state is not advanced.
requestDelayMs	integer	1500	Deliberate pacing before every request. Minimum accepted value is 1000 ms.

---

Example: monitor price and discount changes only

{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "countryCode": "us",
  "eventTypes": [
    "PRICE_CHANGE",
    "DISCOUNT_START",
    "DISCOUNT_END"
  ]
}

---

Example: review momentum monitoring

{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "eventTypes": [
    "REVIEW_SCORE_CHANGE",
    "REVIEW_DELTA"
  ],
  "minReviewDelta": 50
}

---

Example: another pricing region

{
  "appids": ["1091500"],
  "mode": "monitor",
  "countryCode": "br"
}

Because state is stored per app + country, the Brazilian-price baseline remains separate from the US-price baseline.

---

Change-event output

Monitor mode writes one:

CHANGE_EVENT

record per selected detected change.

Example — end of a sale:

{
  "recordType": "CHANGE_EVENT",
  "eventType": "DISCOUNT_END",
  "appid": "1091500",
  "name": "Cyberpunk 2077",
  "url": "https://store.steampowered.com/app/1091500",
  "currency": "USD",
  "oldPriceFinal": 17.99,
  "newPriceFinal": 59.99,
  "oldDiscountPct": 70,
  "newDiscountPct": 0,
  "priceDeltaPct": 233.46,
  "detectedAt": "2026-07-30T13:00:00.000Z"
}

---

Review-delta output

A:

REVIEW_DELTA

event can include:

reviewsDelta
positiveDelta
negativeDelta

This lets downstream workflows observe review-count movement between healthy monitor runs.

The meaning of that movement depends on your own analysis; the Actor does not convert review deltas into estimated unit sales.

---

Free batch summary

Every valid monitor run writes one free:

BATCH_SUMMARY

record.

The summary can include:

• statusCounts;
• eventCounts;
• per-app processing status.

Examples of app statuses include:

OK
BASELINE_CREATED
APP_NOT_FOUND
RATE_LIMITED

This means a valid no-change day still produces useful run-level confirmation.

Example interpretation:

2 apps checked
2 OK
0 change events
1 free BATCH_SUMMARY

---

Persistent monitor state

Diff state is stored in the named key-value store:

STEAM-MONITOR-STATE

with one state key per:

appid!country

This state is what allows later runs to determine what changed.

Force a fresh baseline

Delete a specific app + country key from:

STEAM-MONITOR-STATE

to force the next healthy run to create a new baseline.

Use this deliberately because the previous comparison state for that app + region will be removed.

---

Result-cap state protection

maxResults limits the number of charged output records.

If a particular app's event set would be truncated by the output cap, that app's diff state is not advanced.

This prevents the Actor from silently moving the baseline past change events that were not actually written to the dataset.

---

Regional pricing

Steam prices depend on the selected:

countryCode

The Actor normalizes Steam's price values into currency units.

For example, a source value represented internally in cents is returned as a value such as:

17.99

with the corresponding currency field.

Free games can return:

priceFinal: null
isFree: true

Regional availability also depends on Steam's response for the selected country.

---

Release monitoring

The Actor can monitor the storefront release state.

When a game changes from coming soon to released, the monitor can emit:

RELEASED

This is a release-state event.

The documented event set does not include a separate generic event for every possible release-date text change.

---

Rate-limit handling

Steam rate limits are respected rather than bypassed.

Requests are processed serially with deliberate pacing.

Default request delay:

1500 ms

Minimum:

1000 ms

When Steam responds with:

429

the Actor uses long backoff intervals.

The documented retry timing includes:

30 seconds
60 seconds
120 seconds

If an app remains rate-limited after the controlled retry path, it becomes:

RATE_LIMITED

rather than triggering evasion behavior.

For larger batches, reduce batch size or increase:

requestDelayMs

if needed.

---

One bad app does not kill the batch

An invalid or unavailable app can receive:

APP_NOT_FOUND

without automatically stopping healthy apps in the same run.

The run fails globally only when no app completes successfully, using:

ALL_APPS_FAILED

This makes batch processing safer for portfolios containing stale or regionally unavailable app IDs.

---

Region-specific availability

Steam can return an app successfully in one region and not in another.

For example, an appdetails response can report:

success: false

for one pricing region even when the same app is available elsewhere.

The Actor reports Steam's regional response as-is rather than inventing availability.

---

Run health and diagnostics

Operational data is stored in:

STATS

The run statistics can include:

• per-app summary;
• HTTP counters;
• 429 counts;
• events by type;
• field-completeness checks;
• warnings.

Failures and diagnostic errors can be stored in:

ERRORS

---

Request footprint

The Actor makes approximately:

2 HTTP requests per app per run

using the documented Steam storefront data and review-summary sources.

Because requests are deliberately paced, large batches are intentionally slower than an aggressive high-concurrency scraper.

The original implementation target is approximately:

~5 minutes per 100 apps

under the documented pacing assumptions, although actual runtime depends on network responses and rate limiting.

---

Scheduling

Monitor mode is intended for recurring use.

Diff quality depends on how often you run the Actor.

Why cadence matters

Suppose a game:

1. drops from $59.99 to $39.99;
2. later drops to $29.99;
3. returns to $59.99;

between two monitor runs.

The next comparison sees the current state against the last saved healthy state.

Intermediate changes that occur entirely between runs cannot be reconstructed automatically.

For that reason, daily monitoring is a practical default for competitive price and discount tracking.

---

Recommended daily setup

1. Save your app IDs and monitor configuration as an Apify Task.
2. Run it once to establish the free baseline.
3. Go to Console → Schedules → Create schedule.
4. Add the Task.
5. Choose a daily schedule.
6. Route the resulting events to your downstream system.

Example daily 6:00 AM cron:

0 6 * * *

Possible destinations include:

• Slack;
• Google Sheets;
• databases;
• dashboards;
• webhooks;
• internal analytics pipelines;
• deal-alert systems.

The Actor runs in Apify's cloud, so your local computer does not need to remain on.

---

Pay only for written events or details

This Actor uses Pay Per Event pricing.

In monitor mode, you are billed for change-event records actually written.

The free:

BATCH_SUMMARY

is not billed as a change event.

The first healthy baseline does not create fake paid change events.

Events removed through:

• eventTypes;
• minReviewDelta;
• output caps

are not billed as written change-event records.

In details mode, billing is based on the detail records actually written.

The Pricing tab on the Actor page is always the authoritative source for current prices and any run-start fee.

---

Cost-control options

Use:

eventTypes

to monitor only the event classes you need.

Use:

minReviewDelta

to avoid writing small review-count changes.

Use:

maxResults

to cap charged output records.

You can also split large portfolios into separate scheduled tasks if you want independent cost or monitoring boundaries.

---

Honest limits

You provide the app IDs

The Actor does not discover the full Steam catalog.

Input is based on:

• Steam app IDs;
• Steam Store URLs.

This version intentionally focuses on monitoring a known game portfolio.

No exact sales estimates

Review totals and review deltas are public storefront signals.

The Actor does not convert them into exact unit sales, revenue, or ownership estimates.

Diff quality depends on run cadence

Only the difference between two recorded healthy states is available.

Multiple intermediate changes between runs can collapse into a single observed event.

Rate limits are respected

The Actor deliberately paces requests and backs off on 429 responses.

It does not try to bypass Steam rate limits.

Regional prices differ

Pricing and availability depend on:

countryCode

Monitor state is therefore kept separately by region.

Free games have no normal final price

Free titles can return:

priceFinal: null
isFree: true

Some apps are regionally unavailable

Steam can return different results for the same app in different regions.

The Actor reports the source response.

One failed app does not guarantee run failure

Individual failures are controlled per app.

The batch fails only when no app answers successfully.

---

FAQ

Do I need a Steam API key?

No.

The Actor reads the documented public storefront sources without requiring an API key.

Do I need a Steam account?

No.

No login is required.

Does the Actor use browser automation?

No.

Can I provide Steam Store URLs instead of app IDs?

Yes.

The appids input accepts app IDs or Store URLs.

How many games can I monitor?

Up to:

200

app IDs or Store URLs per run.

What is the default mode?

monitor

What happens on the first monitor run?

The first healthy run for each app + country creates a free baseline.

It does not emit fake change events for the existing state.

What happens if nothing changes?

The run can produce zero change events while still writing the free:

BATCH_SUMMARY

record.

Can I export full game details?

Yes.

Use:

{
  "mode": "details"
}

Can I monitor another pricing region?

Yes.

Set:

countryCode

to the desired supported region code.

Monitor state remains separate by app + country.

Can I monitor only discounts?

Yes.

For example:

{
  "eventTypes": [
    "DISCOUNT_START",
    "DISCOUNT_END"
  ]
}

Can I monitor price changes only?

Yes.

{
  "eventTypes": ["PRICE_CHANGE"]
}

Can I control review-delta sensitivity?

Yes.

Use:

minReviewDelta

For example:

{
  "minReviewDelta": 100
}

requires at least 100 total-review change before a REVIEW_DELTA event is written.

Is review velocity the same as sales?

No.

Review changes may be useful as a market signal but are not exact sales counts.

Does RELEASED mean the exact release date changed?

RELEASED represents a monitored change from coming soon to released.

It should not be described as a generic release-date-change event.

What happens when Steam rate-limits a request?

The Actor uses controlled backoff.

If the app remains unavailable due to rate limiting after the retry path, its status can become:

RATE_LIMITED

What happens if an app ID is invalid?

It can receive:

APP_NOT_FOUND

without stopping other valid apps.

Where is monitor state stored?

In:

STEAM-MONITOR-STATE

one key per app + country.

Can I reset a baseline?

Yes.

Delete the corresponding state key from STEAM-MONITOR-STATE.

What am I charged for?

Change events written in monitor mode or detail records written in details mode.

The monitor BATCH_SUMMARY is free.

Always check the Actor's Pricing tab for current prices and run fees.

Can I schedule it?

Yes.

Daily scheduling is the recommended starting point for change monitoring.

Is this affiliated with Valve or Steam?

No.

This is an unofficial community Actor and is not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam.

---

Part of the JM Forge suite

Also from the same developer:

• Shopify Price, Stock & Catalog Monitor — Batch + Diff — Monitor Shopify stores for price changes, restocks, sell-outs, new products, and removed products.

• Reddit Feed Monitor — Monitor new posts in public subreddits through Reddit's public RSS feed.

• Google, Bing & YouTube Keyword Suggest Scraper — Expand seed keywords into structured long-tail autocomplete suggestions across Google, Bing, and YouTube.

Support

Report issues in the Issues tab of this actor — I respond within 24h. Feature requests welcome.