Steam Live Player Count Monitor

Track live concurrent players for any Steam game, enrich each app with official Store metadata, and compare every observation with the previous saved snapshot.

Use a list of Steam app IDs or Store URLs, run the Actor once or on an Apify schedule, and receive analysis-ready rows for audience spikes, launch performance, update impact, and player decay.

The Actor uses official public Steam JSON endpoints. It needs no Steam account, API key, browser, or proxy.

What does Steam Live Player Count Monitor do?

Steam Live Player Count Monitor turns a game watchlist into timestamped audience observations.

For every unique Steam app ID, it can:

• 🎮 fetch the current concurrent-player count;
• 🏷️ enrich the record with name, type, developer, publisher, and genres;
• 📅 include release metadata and recommendation totals;
• 📈 compare the count with the previous saved observation;
• 🔗 include official source URLs for traceability;
• ⚠️ preserve a per-game error without losing successful watchlist rows.

Run it repeatedly with the same snapshotStoreName to populate previousPlayerCount, absoluteChange, and percentChange.

Who is it for?

Game publishers and studios

Watch your own title and comparable games before and after launches, updates, sales, esports events, or content drops.

Investors and market researchers

Build a timestamped alternative-data series for audience momentum, durability, and portfolio comparison.

Agencies and analysts

Monitor client and competitor titles without maintaining custom Steam API polling infrastructure.

Community operators

Trigger dashboards, alerts, Discord posts, or editorial workflows when a game gains or loses a meaningful share of players.

Data engineering teams

Export typed JSON, CSV, Excel, or API data into warehouses and BI systems.

Why use this Actor?

• Official data route: counts and metadata come from public Steam endpoints.
• No credentials: no Steam Web API key or user login is required.
• Schedule ready: named snapshot storage supports comparisons across runs.
• Watchlist focused: supply exactly the apps relevant to your workflow.
• Partial-failure safe: one unavailable app does not discard other games.
• Low overhead: HTTP-only execution with 256 MB memory and no browser.
• Export friendly: use Apify datasets, webhooks, integrations, API clients, or MCP.

Data you can extract

Field	Type	Description
appId	number	Numeric Steam application ID
name	string	Steam Store game or app name
appType	string	Steam content type, such as game
isFree	boolean	Whether Steam marks the app free to play
developers	string[]	Listed developers
publishers	string[]	Listed publishers
genres	string[]	Steam genre labels
releaseDate	string	Localized Store release date
comingSoon	boolean	Store coming-soon status
recommendationCount	number	Recommendation total when available
currentPlayerCount	number	Live concurrent-player count
previousPlayerCount	number	Count saved by the previous successful run
absoluteChange	number	Current count minus previous count
percentChange	number	Percentage change from the prior count
observedAt	string	UTC ISO timestamp for this observation
storeUrl	string	Steam Store app page
playerCountSourceUrl	string	Official current-player endpoint
appDetailsSourceUrl	string	Official Store metadata endpoint
headerImageUrl	string	Steam header image when available
error	string	Per-app source error when a request failed

Optional fields are omitted when Steam does not provide them.

How to monitor live Steam player counts

1. Open the Actor input page.
2. Add Steam app IDs or Store URLs to appIds.
3. Keep Include game metadata enabled for rich records.
4. Choose a stable snapshotStoreName.
5. Click Start.
6. Review the default dataset.
7. Run again later with the same store name to get delta fields.
8. Add an Apify schedule for recurring monitoring.

A first run has no prior observation, so delta fields are naturally absent. The second and later runs can calculate them.

Input

{
  "appIds": [
    "730",
    "570",
    "https://store.steampowered.com/app/440/Team_Fortress_2/"
  ],
  "includeAppDetails": true,
  "country": "us",
  "language": "english",
  "snapshotStoreName": "my-studio-steam-watchlist",
  "maxConcurrency": 4,
  "maxRequestRetries": 3
}

Input options

Option	Default	Notes
appIds	required	1–100 app IDs or Store URLs
includeAppDetails	true	Disable for count-only polling
country	us	Two-letter Store country code
language	english	Steam language name
snapshotStoreName	steam-live-player-count-snapshots	Named KV store for prior counts
maxConcurrency	4	Allowed range 1–10
maxRequestRetries	3	Allowed range 1–5

Output example

{
  "appId": 730,
  "name": "Counter-Strike 2",
  "appType": "game",
  "isFree": true,
  "developers": ["Valve"],
  "publishers": ["Valve"],
  "genres": ["Action", "Free To Play"],
  "releaseDate": "Aug 21, 2012",
  "currentPlayerCount": 569110,
  "previousPlayerCount": 550000,
  "absoluteChange": 19110,
  "percentChange": 3.47,
  "observedAt": "2026-07-15T02:30:00.000Z",
  "storeUrl": "https://store.steampowered.com/app/730/",
  "playerCountSourceUrl": "https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/?appid=730"
}

Live counts vary continuously. The values above illustrate the output shape, not a guaranteed current value.

How snapshot deltas work

The Actor opens the named Apify key-value store in snapshotStoreName.

After a successful count request, it stores the app ID, count, and observation timestamp. On the next run using that same store name, it compares the new count with the stored value.

Use different store names for independent clients, portfolios, environments, or alerting baselines.

If a count request fails, the previous good value remains in the snapshot store.

If the previous count is zero, absoluteChange is available but percentage change is omitted because division by zero is undefined.

How much does it cost to monitor Steam player counts?

The Actor uses pay-per-event pricing:

• one small monitor start charge per run;
• one game snapshot event for each dataset row.

Tiered per-snapshot prices decrease on higher Apify plans. The exact active price is shown on the Actor pricing tab before you run it.

A three-game watchlist creates three snapshot events. Duplicate IDs are removed before requests and charges.

For cost-efficient scheduling, place related games in one watchlist rather than starting many one-game runs.

Scheduling and alerts

Create an Apify schedule to run the same input hourly, daily, or around a known event.

Useful patterns include:

• hourly launch-week audience monitoring;
• before/after game update comparisons;
• daily competitor portfolio snapshots;
• weekend versus weekday audience analysis;
• webhook alerts when percentChange crosses your threshold.

The Actor calculates deltas; your webhook, automation, or BI tool can decide what constitutes an alert.

Accuracy and freshness

currentPlayerCount is the integer returned by Steam's official current-player endpoint at request time.

Games in one watchlist are fetched concurrently, so their observedAt timestamps can differ slightly.

Store metadata is localized according to country and language. Release-date text can therefore vary by locale.

The Actor does not estimate historical players or reconstruct missing intervals. For a time series, schedule and retain your datasets.

Reliability and error handling

Transient 429 and 5xx responses are retried with exponential backoff.

Concurrency is capped at 10 to avoid unnecessarily aggressive polling.

If player count or metadata fails for one app, the Actor emits the available fields and adds an error string.

Invalid app-ID entries are skipped with a warning. A run fails clearly when no valid app IDs remain.

Tips for better monitoring

• Reuse the same snapshotStoreName across comparable runs.
• Keep separate store names for unrelated watchlists.
• Use numeric app IDs when generating inputs programmatically.
• Keep includeAppDetails enabled for human-readable reports.
• Disable metadata enrichment for high-frequency count-only polling.
• Use conservative concurrency for large watchlists.
• Archive datasets externally if you need long retention or custom aggregation.

Integrations

Google Sheets

Send each scheduled dataset to Sheets for lightweight watchlist dashboards and charts.

Slack or Discord

Use an Apify webhook plus Make, Zapier, or custom code to post large percentage changes.

BigQuery, Snowflake, or PostgreSQL

Load snapshots into a warehouse keyed by appId and observedAt for trend analysis.

Tableau, Power BI, or Looker

Connect exported datasets to audience-performance dashboards.

Webhooks

Trigger downstream processing when a run succeeds, then fetch dataset rows through the Apify API.

API usage

JavaScript example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/steam-live-player-count-monitor').call({
  appIds: ['730', '570', '440'],
  snapshotStoreName: 'weekly-steam-watchlist'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/steam-live-player-count-monitor").call(run_input={
    "appIds": ["730", "570", "440"],
    "snapshotStoreName": "weekly-steam-watchlist"
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

cURL API example

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~steam-live-player-count-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"appIds":["730","570","440"],"snapshotStoreName":"weekly-steam-watchlist"}'

Poll the returned run ID or use the synchronous API endpoint when appropriate for your application.

Use with Apify MCP

Connect Claude and other MCP clients to Apify, then expose this Actor as a tool.

MCP server URL:

https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor

Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor"

Claude Desktop and Cursor

Add this mcpServers JSON to Claude Desktop or Cursor and authenticate when prompted:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/steam-live-player-count-monitor"
    }
  }
}

VS Code

Add the same HTTP MCP server URL through the VS Code MCP server configuration UI, then sign in to Apify.

Example prompts:

• “Run the Steam live player count monitor for app IDs 730, 570, and 440.”
• “Compare today’s Counter-Strike 2 and Dota 2 player counts with the prior snapshot.”
• “Fetch current players and publisher metadata for this list of Steam URLs.”

Limits

• A run accepts up to 100 unique app inputs.
• Steam can throttle clients during high request volume.
• Some apps are delisted, unavailable by region, or do not expose a count.
• Store metadata can be missing for tools, demos, DLC, or unreleased apps.
• The Actor observes current players; it does not provide Steam's private ownership or revenue data.
• Snapshot state is per named KV store, not automatically shared across different store names.

Legality

The Actor accesses public official Steam endpoints without bypassing login or access controls.

You are responsible for using data in accordance with Steam's terms, Apify's terms, applicable laws, and your organization's policies.

Do not use the Actor to overload Steam services. Choose reasonable schedules and conservative concurrency.

This documentation is general information, not legal advice.

Troubleshooting

Why are previous and delta fields missing?

They are expected to be missing on the first successful observation. Run again with exactly the same snapshotStoreName.

Why does one row contain an error?

Steam may have throttled a request, the app may be unavailable, or an endpoint may not expose the requested record. Check the source URL and run logs.

Why is metadata missing but the player count exists?

The Store metadata endpoint can fail or return no data independently of the player-count endpoint. The Actor preserves the useful count.

Why did the run skip an input?

Use a positive numeric Steam app ID or a URL containing /app/<id>/. Other Steam URLs, text names, and search queries are not app identifiers.

FAQ

Does this require a Steam API key?

No. The exact endpoints used by this Actor are anonymously accessible.

Can I monitor games from Store URLs?

Yes. Paste standard store.steampowered.com/app/<id>/... URLs into appIds.

Can I monitor free-to-play and paid games?

Yes, when Steam exposes a current-player response for the app.

Does the Actor store historical time series?

Each run writes a dataset and stores only the latest successful count for delta calculation. Retain datasets or export them to build a long-term series.

Can I turn off metadata requests?

Yes. Set includeAppDetails to false for count-only polling.

Are duplicate IDs charged twice?

No. Normalized app IDs are de-duplicated before output.

Related actors

• Steam Scraper — discover Steam games by keyword and collect prices, discounts, and review summaries.
• Twitch Scraper — complement game audience signals with Twitch channel and stream data.
• YouTube Scraper — collect video and channel signals for game-marketing analysis.

Choose Steam Live Player Count Monitor when you already know the app IDs and need repeatable live audience snapshots and deltas.

Start monitoring

Add a small game watchlist, run the Actor once, and inspect the official live counts.

Then schedule the same input with the same snapshot store to turn isolated observations into useful player-audience changes.