SteamCharts Player-Count Scraper: Up to 1,000 Free Results a Month

Concurrent player metrics cost $5.00 per 1,000 results on the free plan, delivering historical curves back to mid-2012. Records in gameDetails mode return 12 fields, including month-by-month summaries and granular timeseries entries. The scraper captures real-time player counts, peak tracking, and 24-hour trend percentages directly from public leaderboards. It fits game studios, market researchers, and analysts evaluating PC gaming traffic. It is not for anyone who needs pricing, discount histories, or system requirements, which the records do not include.

Try it: open SteamCharts Player-Count Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try SteamCharts Player-Count Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of SteamCharts Player-Count Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

SteamCharts Player-Count Scraper was last updated on 2026-08-03. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 686,269 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run SteamCharts Player-Count Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Controlling maxItems has the largest impact on your total spend by directly bounding emitted dataset records. For gameDetails mode, the length of the appIds list dictates record output. Run a single title check with maxItems capped at 20 to inspect the output structure before pulling wider catalogs.

How do you run SteamCharts Player-Count Scraper from the API?

The schema marks 1 of its 7 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for SteamCharts Player-Count Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~steamcharts-player-count-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"topGames","searchQuery":"counter-strike","appIds":["730"],"includeFullHistory":true,"maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "topGames",
  "searchQuery": "counter-strike",
  "appIds": [
    "730"
  ],
  "includeFullHistory": True,
  "maxItems": 20
}

run = client.actor("crawlerbros~steamcharts-player-count-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "topGames",
  "searchQuery": "counter-strike",
  "appIds": [
    "730"
  ],
  "includeFullHistory": true,
  "maxItems": 20
}

const run = await client.actor('crawlerbros~steamcharts-player-count-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which SteamCharts Player-Count Scraper inputs matter, and which can you skip?

The mode parameter dictates the entire query behavior, toggling between top leaderboards, trending gainers, name search, detailed App ID histories, and all-time peaks. When using gameDetails, appIds is the critical control for pinpointing games. For initial exploratory runs, leave minCurrentPlayers and maxCurrentPlayers unset.

• mode (string): What to fetch from SteamCharts. Default: "topGames".
• searchQuery (string): Game name or partial title to search for, e.g. counter-strike. Matching is decided by SteamCharts' own search index, not a fixed character count - some short queries return matches while some longer ones don't. Try a more distinctive or complete word if you get zero results. Default: "counter-strike".
• appIds (array): One or more numeric Steam App IDs to fetch full details + history for, e.g. 730 (Counter-Strike 2), 570 (Dota 2). Find an App ID in a game's Steam store URL: store.steampowered.com/app/{appId}/. Default: ["730"].
• includeFullHistory (boolean): Fetch the complete average-player history back to when SteamCharts began tracking the game (mid-2012 for the oldest titles) - monthly resolution for older periods, refining to daily/hourly for the most recent months. Disable for a lighter response with only the monthly summary table. Default: true.
• minCurrentPlayers (integer): Drop games with fewer current concurrent players than this (modes: topGames, trending, search).
• maxCurrentPlayers (integer): Drop games with more current concurrent players than this (modes: topGames, trending, search).
• maxItems (integer): Hard cap on the number of records emitted. Default: 20.

Fixed-choice controls: mode accepts topGames (Top games by current players), trending (Trending 24-hour gainers), search (Search games by name), gameDetails (Game details + player-count history (by App ID)), topRecords (All-time peak player records).

What does SteamCharts Player-Count Scraper return?

The records provide structured concurrent player numbers, peak records, and historical monthly trends suited for market analysis and retention tracking. They do not contain Steam store reviews, DLC breakdowns, user tags, or regional pricing data.

topGames` mode

• rank: Current leaderboard position
• appId: Steam App ID
• name: Game title
• currentPlayers: Current concurrent players
• peakPlayers30d: Peak concurrent players in the last 30 days
• hoursPlayed30d: Total hours played across all players in the last 30 days
• imageUrl: Game header image
• sourceUrl: SteamCharts page for this game

search` mode

• appId: Steam App ID
• name: Game title
• currentPlayers: Current concurrent players
• avgPlayers30d: Average concurrent players over the last 30 days
• gain30d: Absolute change in average players over 30 days
• gainPercent30d: Percent change in average players over 30 days
• imageUrl: Game header image
• sourceUrl: SteamCharts page for this game

gameDetails` mode

• appId: Steam App ID
• name: Game title
• currentPlayers: Current concurrent players
• currentPlayersAsOf: UTC timestamp SteamCharts last refreshed the current-player count
• peak24h: Peak concurrent players in the last 24 hours
• peakAllTime: Highest concurrent-player count ever recorded for this game
• storeUrl: Steam store page
• communityHubUrl: Steam Community hub page
• imageUrl: Game header image
• sourceUrl: SteamCharts page for this game
• monthlyHistory[]: Month-by-month summary: month, avgPlayers, gain, gainPercent, peakPlayers
• historicalChartData[]: Complete average-player timeseries: month (YYYY-MM-DD), timestamp (full UTC instant, YYYY-MM-DDTHH:MM:SSZ), avgPlayers - going back to when SteamCharts began tracking the game (mid-2012 for the oldest titles). Resolution isn't uniformly monthly: older periods have one point per calendar month, while the most recent 1-3 months progressively refine to daily or even hourly data points as SteamCharts accumulates fresh samples, so you may see several entries sharing the same month date with different timestamp/avgPlayers values - that's expected, not duplicate/bad data. Use timestamp (not month) to tell same-day points apart or sort them chronologically

topRecords` mode

• appId: Steam App ID
• name: Game title
• allTimePeakPlayers: Highest concurrent-player count ever recorded
• allTimePeakDate: Date/time the record was set (ISO 8601, UTC)
• imageUrl: Game header image
• sourceUrl: SteamCharts page for this game

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open SteamCharts Player-Count Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run mode set to search with searchQuery set to your target title, and confirm the returned item provides the numeric appId.
2. Switch mode to gameDetails, pass the retrieved identifier into the appIds array, and leave includeFullHistory set to true.
3. Verify the output contains monthlyHistory and historicalChartData with populated avgPlayers timestamps.
4. Set minCurrentPlayers or maxCurrentPlayers if you need to discard inactive titles when querying leaderboards.
5. Set maxItems to 20 for an initial test run to verify schema consistency before running broader collection batches.
6. Inspect recordType and scrapedAt on the emitted dataset records to verify ingestion recency.

How do you apply it? Three worked playbooks

These are SteamCharts Player-Count Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Market research

Outcome: Track which games are gaining or losing player share over time

Configure: Set mode to topGames and maxItems to 100.

Working method: Execute a scheduled weekly run to extract top titles, calculating net change across currentPlayers, peakPlayers30d, and hoursPlayed30d against previous snapshots.

Deliverable: A weekly tabular report tracking market share trends across the top 100 Steam titles.

Stop condition: Stop if the dataset returns fewer records than the requested maxItems threshold.

Use case 2: Game developer competitive intelligence

Outcome: Benchmark your game's concurrent players against competitors in the same genre

Configure: Set mode to gameDetails, appIds to a list of target genre competitors like ["730", "570"], and includeFullHistory to true.

Working method: Pull long-term timeseries data to compare peak24h, peakAllTime, and historical monthly curves against your own title launch timeline.

Deliverable: A cross-title retention and player-count comparison matrix spanning monthly historical milestones.

Stop condition: Stop if any requested appId fails to generate a record in the dataset.

Use case 3: Esports & gaming media

Outcome: Surface trending titles and breakout hits for coverage

Configure: Set mode to trending with maxItems set to 10.

Working method: Query trending gainers daily, ranking records by gainPercent24h to spot breakout titles experiencing sudden volume spikes.

Deliverable: A daily alert list of fastest-growing Steam titles by 24-hour player growth percentage.

Stop condition: Stop if gainPercent24h is missing from the emitted trending items.

What breaks, and how do you design around it?

Historical timeseries data in historicalChartData refines to daily or hourly resolution for recent months, producing multiple timestamps sharing the same month label. Use timestamp rather than month to sort recent entries chronologically. If you need broader store data outside player numbers, switch queries to dedicated metadata tools.

When should you not use SteamCharts Player-Count Scraper?

Do not use this Actor if your project requires store metadata, price tracking, publisher details, or user reviews. SteamCharts only indexes player counts and activity curves. If you need comprehensive Steam store catalog entries including system specifications, store descriptions, and categories, use Steam Game Scraper. If your goal is monitoring pricing drops and digital store promotions across multiple PC storefronts, use IsThereAnyDeal / CheapShark Game Deals Scraper. Furthermore, if you only need raw live concurrent user counts without historical context, query Valve's official public API endpoints directly at zero operational cost.

What should you check before trusting the output?

• Verify that appId is a valid numeric string and never omitted across emitted records.
• Ensure historicalChartData entries contain non-null timestamp strings in ISO 8601 UTC format.
• Check that currentPlayers is a non-negative integer when auditing active titles.
• Flag any gameDetails run where monthlyHistory is empty despite the game having a known long-term catalog presence.

None of this proves a record is correct. It gives a scheduled SteamCharts Player-Count Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does running this Actor cost on Apify?

Results cost $0.005 per result, which is $5.00 per 1,000 results on the free plan. Apify also bills platform usage per run, alongside a memory-based run-start fee charged every time a run begins.

Can I search for games directly by title in gameDetails mode?

No. The gameDetails mode accepts numeric Steam App IDs in the appIds array. Run mode search first with your title in searchQuery to retrieve the correct appId, then feed that identifier into gameDetails.

Why do some entries in historicalChartData share identical month values?

SteamCharts provides monthly granularity for older periods, but the most recent months include daily or hourly data points. Entries sharing a month value represent successive samples; differentiate and sort them using the full UTC timestamp field.

Does trending mode return every game with positive daily growth?

No. SteamCharts publishes a fixed, curated list of the day's highest percentage gainers, usually under 10 games. Setting maxItems higher acts as an upper ceiling rather than guaranteeing a larger output.

What happens if a field has no data for a game?

Fields without available values are omitted completely from the dataset output. You will not see null values, empty strings, or placeholder text in the emitted records.

Where to go next

When you are ready to run it, open SteamCharts Player-Count Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• Steam Game Scraper: Extract comprehensive game data from Steam store pages.
• IsThereAnyDeal / CheapShark Game Deals Scraper: Scrape PC game deals from 35+ stores with Steam, GOG, Epic, Fanatical and more.
• ESPN Rosters & Player Stats: Scrape team rosters and player career statistics from ESPN across 16 leagues and 5 sports.
• Bricklink Scraper: Scrape BrickLink - the world's largest LEGO marketplace.
• StatMuse Scraper: Scrape StatMuse sports statistics - ask natural language questions about NBA, NFL, MLB, and NHL stats.
• Chess.com Scraper: Scrape Chess.com - leaderboards, player profiles, stats, and game archives.
• Lichess Scraper: Scrape Lichess - the world's most popular open-source chess platform with 3M+ daily games.
• NHL Stats Scraper: Scrape NHL team rosters, player profiles, and game results using TheSportsDB free API.

Related guides:

• ATP Live Rankings Scraper: 10 Data Fields per Record (2026)
• East Money Scraper: 48 Data Fields, Up to 1,000 Free Results/Month

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-27.

• Actor last updated by its maintainers on 2026-08-03.

• Run outcome figures cover the 30 day public window ending 2026-09-27.

• SteamCharts Player-Count Scraper on Apify