# Steam Store Scraper 🎮 (`shahidirfan/steam-store-scraper`) Actor

Unlock comprehensive data from the Steam Store with ease. This efficient actor scrapes game details, pricing, reviews, and tags at high speed. Perfect for market research, price monitoring, and analyzing gaming trends without the hassle.

- **URL**: https://apify.com/shahidirfan/steam-store-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Developer tools, E-commerce, Other
- **Features:** Limited permissions
- **Stats:** 48 total users, 15 monthly users, 98.9% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Steam Store Scraper do?

Steam Store Scraper collects structured game data from the Steam Store. Search by keyword or paste a Steam search URL, then export titles, prices, discounts, release dates, genres, platforms, developers, publishers, media links, and system requirements. Each dataset item includes a direct Steam URL, a source label, and an ISO timestamp.

### Why use Steam Store Scraper?

- **Build a game catalog** - Collect Steam titles by keyword, sort order, or a custom search URL.
- **Track prices and discounts** - Save current prices, original prices, discount percentages, and sale status.
- **Enrich an existing database** - Add descriptions, genres, categories, media, requirements, and company names to game records you already own.
- **Follow releases** - Capture release dates and filter out unreleased titles when you need a released-only dataset.
- **Localize prices** - Choose the country code and language used for prices and text.
- **Run at scale** - Save progress after each search page. A long job can continue from the last saved position instead of restarting at page one.

### What data can you extract from Steam?

Each record covers one app. Steam omits fields it does not publish.

| Field | Type | Description |
|-------|------|-------------|
| `appId` | String | Steam application identifier. |
| `url` | String | Direct Steam Store URL for the app. |
| `title` | String | Game or item title. |
| `type` | String | Steam item type, such as `game`, `dlc`, or `demo`. |
| `description` | String | Short store description. |
| `detailedDescription` | String | Full store description converted to plain text. |
| `aboutTheGame` | String | About This Game content when provided. |
| `headerImage` | String | Header image URL. |
| `capsuleImage` | String | Capsule image URL. |
| `screenshots` | Array | Full-size screenshot URLs. |
| `movies` | Array | Trailer URLs when available. |
| `releaseDate` | String | Release date shown by Steam. |
| `comingSoon` | Boolean | Whether the item is marked as unreleased. |
| `isFree` | Boolean | Whether Steam marks the item as free. |
| `supportedLanguages` | String | Languages listed by Steam. |
| `supportedPlatforms` | Array | Platform keys: `windows`, `mac`, `linux`. |
| `platforms` | Array | Same platform list, kept for dataset views. |
| `genres` | Array | Steam genre labels. |
| `categories` | Array | Steam feature and category labels. |
| `tags` | Array | Community tags when the store page fallback is used. |
| `developers` | Array | Developer names. |
| `publishers` | Array | Publisher names. |
| `price` | String | Current localized price or `Free`. |
| `priceCents` | Number | Price in the smallest currency unit when available. |
| `currency` | String | Currency code such as `USD`. |
| `originalPrice` | String | Pre-discount price when a sale is active. |
| `discountPercent` | String | Discount value such as `50%`. |
| `sale` | Boolean | Whether the item currently has a discount. |
| `reviewSummary` | String | Steam review label such as `Very Positive`. |
| `recommendationsTotal` | Number | Steam recommendation count when available. |
| `achievementsTotal` | Number | Achievement count when available. |
| `metacriticScore` | Number | Metacritic score when Steam publishes one. |
| `metacriticUrl` | String | Metacritic page linked by Steam. |
| `website` | String | Official website listed on the store page. |
| `supportInfo` | Object | Support URL and email when provided. |
| `pcRequirements` | Object | Minimum and recommended Windows requirements. |
| `macRequirements` | Object | Minimum and recommended macOS requirements. |
| `linuxRequirements` | Object | Minimum and recommended Linux requirements. |
| `systemRequirements` | Object | Minimum requirements grouped by platform. |
| `isDLC` | Boolean | Whether the item is downloadable content. |
| `dlc` | Array | Related DLC application identifiers. |
| `packages` | Array | Package identifiers associated with the item. |
| `packageGroups` | Array | Purchase option details when available. |
| `contentDescriptors` | Object | Content descriptors supplied by Steam. |
| `background` | String | Background image URL. |
| `backgroundRaw` | String | Raw background image URL. |
| `searchPosition` | Number | Position of the item in the search results. |
| `source` | String | Record source: `steam-appdetails`, `steam-store-browse`, `steam-store-page`, or `steam-search-results`. |
| `enrichmentFailed` | Boolean | True when full details were unavailable and fallback data was used. |
| `scrapedAt` | String | ISO timestamp for when the record was saved. |

### How to use Steam Store Scraper

1. Open the Actor in Apify Console.
2. Enter a keyword, or paste a Steam search URL.
3. Set the result limit and page limit.
4. Choose the sort order, language, country, and optional sale or release filters.
5. Start the run.
6. Download the dataset or connect it to your workflow.

A supplied search URL takes precedence over the keyword. This keeps URL-only runs from picking up the prefilled keyword.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | String | No | - | A Steam search URL. Its filters are reused and take precedence over `keyword`. |
| `keyword` | String | No | `action` | Search term such as `action`, `RPG`, or `survival`. Leave it empty to scan the whole store. |
| `sortBy` | String | No | `_ASC` | Sort order: `_ASC`, `Released_DESC`, `Price_ASC`, `Price_DESC`, `Name_ASC`, or `Reviews_DESC`. |
| `maxResults` | Integer | No | `20` | Overall number of games to collect. On a resumed run, this is the total target, not an extra count. |
| `maxPages` | Integer | No | `5` | Maximum search pages to scan in one run. Steam returns up to 50 games per page. A resumed run continues from the saved page. |
| `onlyOnSale` | Boolean | No | `false` | Save only items with an active discount. |
| `onlyReleased` | Boolean | No | `true` | Exclude items marked as coming soon. |
| `language` | String | No | `english` | Language used for localized fields. |
| `countryCode` | String | No | `us` | Two-letter country code used for prices and availability. |
| `proxyConfiguration` | Object | No | Apify Proxy | Apify Proxy is used by default. The Actor prefers the DATACENTER group, falls back to the account default group, and uses custom proxy URLs when supplied. |

### Usage Examples

#### Basic keyword run

Collect 20 action games with the default release filter:

```json
{
  "keyword": "action",
  "maxResults": 20,
  "maxPages": 5
}
```

#### Large resumable job

Collect up to 50,000 games from the whole store. The search URL has no term, so discovery is not limited to one keyword. Set the Apify run timeout to 6 hours. If the job stops early, run it again with the same search. Resume is automatic.

```json
{
  "startUrl": "https://store.steampowered.com/search/?sort_by=_ASC",
  "maxResults": 50000,
  "maxPages": 1200,
  "onlyReleased": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Discounted RPG catalog

Return released RPGs with an active discount and scan more pages:

```json
{
  "keyword": "RPG",
  "sortBy": "Price_ASC",
  "maxResults": 500,
  "maxPages": 20,
  "onlyOnSale": true,
  "onlyReleased": true
}
```

#### Custom search URL with localization

Reuse a Steam search URL and collect prices for the United Kingdom:

```json
{
  "startUrl": "https://store.steampowered.com/search/?sort_by=Reviews_DESC&term=survival",
  "maxResults": 100,
  "maxPages": 10,
  "language": "english",
  "countryCode": "gb"
}
```

### Sample Output

Prices, counts, and available fields vary by title, country, and collection time.

```json
{
  "appId": "413150",
  "url": "https://store.steampowered.com/app/413150/Stardew_Valley/",
  "title": "Stardew Valley",
  "type": "game",
  "description": "You've inherited your grandfather's old farm plot in Stardew Valley. Armed with hand-me-down tools and a few coins, you set out to begin your new life.",
  "releaseDate": "Feb 26, 2016",
  "comingSoon": false,
  "isFree": false,
  "supportedLanguages": "English, German, Spanish - Spain, Japanese, Portuguese - Brazil, Russian, Simplified Chinese, French, Italian, Hungarian, Korean, Turkish",
  "supportedPlatforms": ["windows", "mac", "linux"],
  "platforms": ["windows", "mac", "linux"],
  "genres": ["Indie", "RPG", "Simulation"],
  "categories": ["Single-player", "Multi-player", "Co-op", "Online Co-op"],
  "developers": ["ConcernedApe"],
  "publishers": ["ConcernedApe"],
  "price": "$14.99",
  "priceCents": 1499,
  "currency": "USD",
  "sale": false,
  "reviewSummary": "Overwhelmingly Positive",
  "recommendationsTotal": 903228,
  "achievementsTotal": 49,
  "metacriticScore": 89,
  "website": "http://www.stardewvalley.net",
  "screenshots": [
    "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/413150/ss_b887651a93b0525739049eb4194f633de2df75be.1920x1080.jpg"
  ],
  "pcRequirements": {
    "minimum": "Minimum: OS *: Windows Vista or greater Processor: 2 Ghz Memory: 2 GB RAM Graphics: 256 mb video memory, shader model 3.0+ DirectX: Version 10 Storage: 500 MB available space"
  },
  "searchPosition": 1,
  "source": "steam-appdetails",
  "enrichmentFailed": false,
  "scrapedAt": "2026-11-03T06:02:30.461Z"
}
```

### Large runs and resume behavior

Steam limits how many requests one IP can make in a five-minute window. The Actor tracks a separate request budget per proxy session, rotates its request profile when Steam applies a block, and slows down before it hits a wall. A 5,000 game run took 4m 24s with 6 proxy sessions; without a proxy it is slower.

The Actor saves its position after each search page. If a run stops because of the Apify timeout or a sustained Steam block, the next run with the same search continues from the saved position. The summary reports two numbers: games saved by the current run, and overall progress toward `maxResults`.

The Actor always uses fast batched data. It fetches core records in batches of 50 app IDs, avoiding one request per game. In a 20-game comparison it returned 33 fields, compared with 51 from per-game detail records. It keeps names, descriptions, developers, publishers, release dates, platforms, prices, discounts, reviews, tags, images, screenshots, and trailers. It omits achievements, categories, content descriptors, currency, DLC lists, genres, macOS and Linux requirements, Metacritic, packages, recommendations, required age, support details, supported languages, system requirements, and website.

Each Apify run writes its own dataset. When a job spans several runs, export or merge those datasets if you need one combined file.

### Tips for Best Results

- Start with `maxResults: 20` and a low `maxPages` value to check the result shape.
- Use a focused keyword or search URL for a narrow catalog.
- Keep language and country consistent so prices stay comparable.
- Raise `maxPages` when a keyword returns more results than the first page.
- For a 50,000 game released-only job, use at least 1,200 search pages. Filters and delisted titles reduce the number of saved records below the raw page count of 50 per page.
- Expect missing fields on delisted or region-locked titles.
- Check `source` and `enrichmentFailed` to judge record completeness.

### Integrations and Export Formats

- **Google Sheets** - Review prices, release dates, and classifications in a shared spreadsheet.
- **Airtable** - Build a searchable game catalog with filters and linked records.
- **Make or Zapier** - Start downstream workflows when a run completes.
- **Webhooks** - Send dataset and run events to your own services.
- **Apify API** - Start runs and retrieve dataset items programmatically. Datasets can be exported as JSON, CSV, Excel, XML, and other supported formats.

### Frequently Asked Questions

#### Is there a fixed five-minute timeout?

No. The Actor uses the run timeout set in Apify. It stops shortly before that timeout so it can save progress and finish cleanly.

#### Can the Actor process 50,000 games in one run?

Yes, with a long run timeout. A 6-hour run with the built-in 6 proxy sessions is a realistic 50,000 game setup. If it does not finish, rerun and resume continues.

#### Does the Actor resume from the last search page?

Yes. Progress is saved after each page and after each saved batch. A new run with the same search, sort, language, country, and filters continues from that point.

#### Why did I get fewer records than `maxResults`?

The usual causes are a low `maxPages`, sale or release filters, fewer Steam results, or the run timeout. Check the run summary for the stop reason and filter counts.

#### Can I scan the whole Steam store instead of one keyword?

Yes. Leave `keyword` empty, or supply a Steam search URL without a term in `startUrl`, for example `https://store.steampowered.com/search/?sort_by=_ASC`. A supplied URL takes precedence over the keyword.

#### Can I use my own Steam search URL?

Yes. Put a public Steam search URL in `startUrl`. The Actor keeps its filters and controls pagination from the input fields. `startUrl` wins when both a URL and a keyword are present.

#### Can I collect only discounted or released games?

Set `onlyOnSale` to `true` for discounts. Keep `onlyReleased` set to `true` to exclude unreleased titles.

#### Are prices localized?

Yes. Set `countryCode` for the market and `language` for localized text. Steam decides which fields and currencies are available for that market.

#### Why are some fields missing?

Steam does not publish every field for every app. Missing descriptions, scores, media, requirements, or package details are omitted when the source does not provide them.

### Related Actors

- [itch.io Games Scraper](https://apify.com/shahidirfan/itch-io-games-scraper) - Collect indie game listings, metadata, and pricing from itch.io.
- [Xbox Games Scraper](https://apify.com/shahidirfan/xbox-games-scraper) - Collect Xbox titles, prices, release dates, and catalog details.

### Support

For issues, missing fields, or feature requests, use the Issues tab on the Actor page. Include the input used, the affected Steam URL, and the run ID when possible.

### Legal Notice

This Actor is intended for legitimate collection and analysis of publicly available Steam Store information. You are responsible for complying with Steam's terms, applicable laws, privacy requirements, and any rules that apply to your use of the data.

# Actor input Schema

## `startUrl` (type: `string`):

A Steam search URL whose filters are reused. When supplied, it takes precedence over the keyword.

## `keyword` (type: `string`):

Keyword to search, for example action, RPG or survival. The default is action. Leave it empty to scan the whole store.

## `sortBy` (type: `string`):

Sort order for Steam search results.

## `maxResults` (type: `integer`):

Total number of games to collect. On a resumed run, this is the overall target, not an additional count.

## `maxPages` (type: `integer`):

Maximum Steam search pages to scan in one run. Steam returns up to 50 games per page. A resumed run continues from the saved page.

## `onlyOnSale` (type: `boolean`):

If enabled, returns only discounted games.

## `onlyReleased` (type: `boolean`):

If enabled, excludes games that have not been released yet.

## `language` (type: `string`):

Steam language used for localized fields.

## `countryCode` (type: `string`):

Two-letter country code used for prices and availability.

## `proxyConfiguration` (type: `object`):

Uses Apify Proxy by default, preferring the DATACENTER group when the account has access and falling back to the account default group. Set useApifyProxy to false to run without a proxy.

## Actor input object example

```json
{
  "startUrl": "https://store.steampowered.com/search/?sort_by=Reviews_DESC&term=action",
  "keyword": "action",
  "sortBy": "_ASC",
  "maxResults": 20,
  "maxPages": 5,
  "onlyOnSale": false,
  "onlyReleased": true,
  "language": "english",
  "countryCode": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "action"
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/steam-store-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "keyword": "action" }

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/steam-store-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "action"
}' |
apify call shahidirfan/steam-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shahidirfan/steam-store-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zBdFeBK4W520hJdq4/builds/7jZrdan4dO6QJsXsq/openapi.json