Steam Store Games Scraper

Extract Steam Store games into a dataset for game-market research, catalog enrichment and localized price comparisons. Supply app IDs, Steam app URLs or search terms to collect names, prices, discounts, release dates, genres, platforms and optional review summaries.

Steam Store Games Scraper reads public Store information without a Steam login. Search terms are text queries, not guaranteed genre or release-status filters. Optional fields depend on what Steam makes available.

Quick start

Open the input form, paste this JSON and select Start. When the run finishes, open its dataset to review or export the results.

{
  "appIds": ["570"],
  "searchTerms": [],
  "maxItems": 1,
  "country": "US",
  "language": "english"
}

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

Choose an example to start with a preconfigured input.

• Steam strategy games for market research — Discover text matches for “strategy” and collect up to 25 app records. Check the returned genres before treating them as a genre-specific catalog.
• Steam games with review summaries — Look up two known games and include public review scores and positive/negative totals.
• Steam game prices for Germany — Retrieve three known apps using German language and country settings. Free games may have no numeric price.

What you get

• One dataset record per usable, unique Steam app, with its app ID and Store URL.
• Available prices, currency, discount, release date, genres, developers, publishers and supported platforms.
• Optional descriptions, screenshot URLs, DLC app IDs and review summaries.
• Downloadable JSON, CSV or Excel for further analysis. The Actor collects snapshots, not historical price changes.

Who is it for?

• Game-market researchers reviewing bounded public Store samples.
• Publishers and indie studios preparing source-linked comparison lists.
• Catalog teams enriching known Steam app identifiers.
• Data analysts comparing localized metadata in their own retained snapshots.

How you can use the data

• Enrich the known Dota 2 app. Use app ID 570 with search terms cleared, a one-row cap, US country and English language. Keep Store URL, app type and platform metadata without assuming every app is a game or every free app has a numeric zero price.
• Discover text matches before classifying. Use the existing strategy games query with a small candidate cap and no direct IDs. Inspect returned genres and app types yourself: this is text discovery rather than an exact strategy-genre or release-status filter.
• Compare localized details deliberately. Request the same known app under the intended country and language, retaining currency and formatted price with numeric values. Country affects details rather than search discovery, and prices are currency units rather than cents.
• Choose optional evidence for your own analysis. Enable review summaries only when aggregate scores and positive/negative totals matter. They are not individual review text, and a failed optional summary can retain a valid base record with null aggregates. Screenshots are links and DLC IDs do not fetch every DLC's details. Compare exports separately if you need history.

Input settings

Setting	Purpose
appIds	Numeric Steam app IDs or app URLs. Processed before search terms.
searchTerms	Text queries used to discover apps. Supply these, app IDs or both.
maxItems	Candidate/result cap from 1 to 10,000. API default is 10. Form prefill is 5.
country	Two-letter country code for detail prices. Default: US.
language	Steam language code. Default: english.
includeDescriptions	Include available short description and website. Default: true.
includeScreenshots	Include screenshot URLs. Default: false.
includeDlc	Include DLC app IDs, without fetching their details. Default: false.
includeReviewsSummary	Include public review scores and totals. Default: false.

At least one app ID or non-empty search term is required. The Actor uses direct access and has no configurable proxy option. Detailed behavior and limits are in each input field's help.

Search input recipe

{
  "appIds": [],
  "searchTerms": ["strategy games"],
  "maxItems": 25,
  "country": "US",
  "language": "english"
}

App IDs found through multiple inputs are deduplicated. Unavailable candidates can reduce the result count below maxItems.

Output data

The default dataset contains Steam app records. This is an illustrative field shape, not a newly measured Steam response:

{
  "appId": 570,
  "name": "Dota 2",
  "type": "game",
  "isFree": true,
  "price": null,
  "currency": null,
  "discountPercent": null,
  "genres": [],
  "developers": [],
  "publishers": [],
  "storeUrl": "https://store.steampowered.com/app/570/"
}

Fields	Meaning
appId, name, type, storeUrl	Steam identity, app type and source link. Legacy aliases appType and url remain available.
isFree, price, initialPrice, currency, discountPercent, priceFormatted	Available localized pricing. Numeric prices are in currency units, not cents.
releaseDate, comingSoon	Steam's release text and coming-soon flag.
developers, publishers, genres, categories, platforms	Store classification and platform metadata.
metacriticScore, recommendationsTotal	Available score and recommendation count.
reviewSummary, reviewScore, reviewScoreDescription, totalPositiveReviews, totalNegativeReviews	Optional review aggregates, not individual review text.
headerImage, capsuleImage, screenshots	Image URLs. Screenshots are optional.
shortDescription, website, dlcAppIds	Optional descriptions, website and DLC IDs.
sourceSearchTerm, scrapedAt	Discovery query, when applicable, and collection timestamp.

Optional values can be null, empty arrays or empty objects. Review fields are null unless requested and available. A free game's price can be null rather than zero. Consult isFree and priceFormatted alongside numeric pricing.

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

This Actor uses pay-per-event pricing. The start event is a one-time run-start charge after input validation, including valid searches that return no matches.

The item event is charged for each usable Steam app record saved. Skipped unavailable apps do not add an item charge. maxItems limits candidates and results, not all platform usage.

See the live Pricing tab for current rates and discounts.

Tips for best results

• Start with known app IDs. This gives you a precise target before trying broader search queries.
• Keep the first batch small. Check the returned app types and genres before increasing maxItems.
• Choose a consistent locale. Use the same country and language when comparing snapshots.
• Request only the optional data you need. Review summaries add a separate lookup per app.

Limits and caveats

Steam controls availability and completeness. Missing, restricted or removed app details cannot be inferred from inaccessibility alone. Optional review-summary failures leave the base game record intact with null review fields.

Valid searches with no matches and apps whose detail response explicitly reports unavailability succeed with an empty dataset. Mixed batches retain available app records. RUN_SUMMARY in the key-value store gives per-input outcomes and a run-level reason, without assuming why an app is unavailable. Deadline-limited batches retain PENDING_WORK and are marked partial, not completed empty results. Malformed responses, request failures, invalid input, essential storage and billing errors still fail. Already saved records remain available. Empty success does not establish complete catalog coverage.

Search terms are sent to Steam's text search. Steam controls ranking and matching. Saved details must match the requested app ID, even if Steam changes the response key. Mismatched or ambiguous detail identities fail rather than saving unrelated records.

Search queries do not implement dedicated genre, sale, VR, free-to-play or upcoming-game filters. country localizes detail requests, not search discovery. App types can include more than games. The Actor does not collect private libraries, ownership data, individual review text or Steam account information.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~steam-store-games-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"appIds":["570"],"searchTerms":[],"maxItems":1}'
# After the run finishes, substitute its defaultDatasetId:
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer $APIFY_TOKEN"

Node.js

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/steam-store-games-scraper').call({
  appIds: ['570'], searchTerms: [], maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/steam-store-games-scraper').call(
    run_input={'appIds': ['570'], 'searchTerms': [], 'maxItems': 1}
)
print(client.dataset(run['defaultDatasetId']).list_items().items)

MCP and AI agents

You can ask your AI assistant to collect data with Steam Store Games Scraper and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Steam Store Games Scraper. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/steam-store-games-scraper"
    }
  }
}

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Steam Store Games Scraper by Fetch Cat, or give it the identifier fetch_cat/steam-store-games-scraper.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Steam Store Games Scraper to retrieve app 570 with search terms cleared, a one-row cap, US country and English language. Keep genres, platforms and free-status context without converting a missing price into zero.”
• “Collect up to 5 Steam app candidates matching strategy games with direct app IDs cleared, US country and English language. Keep app types, genres and Store links without claiming an exact genre catalog or complete coverage.”
• “Retrieve app 570 with search terms cleared, a one-row cap, Germany country and German language, including public review summaries. Keep aggregate review counts and localized price fields, leaving unavailable summaries null rather than collecting review text.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Can I scrape a specific Steam game?

Yes. Add its numeric app ID or Steam app URL to appIds. Use an empty searchTerms array when you only want those apps.

Can I build a Steam Store games dataset for analysis?

Yes. Use app IDs or text searches, then export the dataset. Check app types and genres yourself. The Actor does not guarantee a complete Steam catalog or supply historical data.

Can I localize prices?

Yes. Set country and language for the detail records you need. Availability and optional fields can vary. Free games may have null numeric prices.

Does it collect individual reviews?

No. Enable includeReviewsSummary for public scores and aggregate positive/negative counts, not review text.

Can I use it through an API or AI assistant?

Yes. Use the API examples or hosted MCP setup above. Both use the same input settings and normal Apify charges.

What happens if no games match?

A valid search with no candidates succeeds empty, as do detail responses that explicitly report the requested apps unavailable. Malformed, mismatched or failed requests remain failures. Deadline-limited pending work is partial rather than completed empty. The start charge still applies after valid input is accepted, while no saved rows means no item charges.

Related Actors

• Apple App Store Apps Scraper — Enrich a separate mobile-app catalog for cross-market research.
• Reddit Scraper — Research public gaming discussions separately from Store metadata.
• Google Play Apps Scraper — Collect mobile app metadata for a separate app-market comparison.
• Twitch Streams and Channels Scraper — Research public streaming activity alongside your game-market dataset.
• Amazon Products & Search Scraper — Collect marketplace products for a separate retail catalog workflow.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review from the Actor page to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥