# Steam Store Game Search Scraper (`w3crawler/steam-game-scraper`) Actor

Collects public Steam Store game search results with titles, App IDs, links, prices, discounts, review summaries, release dates, and platform labels.

- **URL**: https://apify.com/w3crawler/steam-game-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 games

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Steam Store Game Search Scraper

Search the **official Steam Store catalogue** and save public game listing records: App ID, title, canonical store URL, displayed price, discount, review label, release text, platform labels, and search position. The Actor uses the Store search page as its source and keeps the source URL, final URL, page URL, source kind, query, sort, and collection timestamp with each saved row.

### Get started

1. Open the [Actor Store page](https://apify.com/w3crawler/steam-game-scraper) and select **Try for free** or open the **Input** tab.
2. Set `searchQuery` to the game or phrase you need. An empty value lists games using the selected sort.
3. Choose `sortBy` and keep `maxItems` small for a first test.
4. Start the Actor, open the dataset, and export the saved records as JSON, CSV, or Excel. Open **Run summary** (`OUTPUT`) to check the outcome and counts.

### Input

All fields are optional; the defaults below are ready to use. Unsupported field names and out-of-range values are rejected before requests start.

| Field | Type | Required? | Default | Meaning |
| --- | --- | --- | --- | --- |
| `searchQuery` | string | Optional | `""` | Public Steam Store search text; an empty value lists games using the selected sort. Up to 200 characters. |
| `query` | string | Optional | Not supplied | Compatibility alias for `searchQuery`, up to 200 characters. |
| `sortBy` | string enum | Optional | `Review_Score_DESC` | `Review_Score_DESC`, `Released_DESC`, `Price_ASC`, `Price_DESC`, or `_ASC`. |
| `maxItems` | integer | Optional | `50` | Maximum unique public game rows to save, 1–500. |
| `delayMs` | integer | Optional | `750` | Minimum serial delay between Steam requests, 250–10,000 ms. |
| `maxRequestRetries` | integer | Optional | `1` | Bounded retries for transient responses only, 0–3. |
| `timeoutMs` | integer | Optional | `30000` | Maximum time for one public Steam response, 5,000–120,000 ms. |
| `maxResponseBytes` | integer | Optional | `5000000` | Maximum response size accepted for parsing, 100,000–30,000,000 bytes. |

Example input matching the saved `portal` run:

```json
{
  "searchQuery": "portal",
  "sortBy": "Review_Score_DESC",
  "maxItems": 2,
  "delayMs": 250,
  "maxRequestRetries": 1,
  "timeoutMs": 30000,
  "maxResponseBytes": 5000000
}
```

The Actor reads the official public Steam Store search page. It does not log in or bypass access controls.

### Output

The dataset contains one row per saved game search result. Optional values are omitted when Steam does not publish them; they are not inferred. No diagnostic or placeholder rows are written.

| Field | Type | Availability | Meaning |
| --- | --- | --- | --- |
| `recordType` | string | Always | Record type; always `steam-game`. |
| `sourceName` | string | Always | Human-readable source name. |
| `sourceUrl` | string | Always | Exact public search URL requested. |
| `sourceFinalUrl` | string | Always | Final public URL after redirects. |
| `sourceKind` | string | Always | Source kind, `search_html`. |
| `pageUrl` | string | Always | Public search page URL. |
| `appId` | integer | Always | Steam application ID. |
| `title` | string | Always | Public game title. |
| `url` | string | Always | Canonical public Steam Store game URL. |
| `headerImage` | string | Always | Public capsule image URL. |
| `releaseDate` | string | Always | Release text shown in the search result. |
| `reviewSummary` | string | Always | Review label shown by Steam, such as `Overwhelmingly Positive`. |
| `reviewScore` | string | Always | Review percentage shown by Steam. |
| `price` | string | Always | Displayed price string, including currency symbol. |
| `originalPrice` | string | When published | Original price string when a discount is shown. |
| `discountPercent` | integer | When published | Discount percentage when a discount is shown. |
| `platforms` | string | Always | Platform labels shown by Steam. |
| `searchQuery` | string | Always | Search term used for the request. |
| `sortBy` | string | Always | Sort parameter used for the request. |
| `position` | integer | Always | One-based position in the saved search results. |
| `scrapedAt` | string | Always | Time the record was saved, in ISO UTC. |

The example below is a real saved row from the 2026-10-25 run. Every value is unchanged.

```json
{
  "recordType": "steam-game",
  "sourceName": "Steam Store game search",
  "sourceUrl": "https://store.steampowered.com/search/?term=portal&sort_by=Review_Score_DESC&start=0&category1=998",
  "sourceFinalUrl": "https://store.steampowered.com/search/?term=portal&sort_by=Review_Score_DESC&start=0&category1=998",
  "sourceKind": "search_html",
  "pageUrl": "https://store.steampowered.com/search/?term=portal&sort_by=Review_Score_DESC&start=0&category1=998",
  "appId": 400,
  "title": "Portal",
  "url": "https://store.steampowered.com/app/400/Portal/",
  "headerImage": "https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/400/capsule_231x87.jpg?t=1745368554",
  "releaseDate": "Oct 10, 2007",
  "reviewSummary": "Overwhelmingly Positive",
  "reviewScore": "98%",
  "price": "$9.99",
  "platforms": "Windows, Linux/SteamOS",
  "searchQuery": "portal",
  "sortBy": "Review_Score_DESC",
  "position": 1,
  "scrapedAt": "2026-10-25T21:13:17.994Z"
}
```

### Run summary

**Run summary** is stored separately from the dataset in the run's key-value store under `OUTPUT` (and mirrored to `OUTPUT_SUMMARY`).

| Field | Meaning |
| --- | --- |
| `recordType` | Summary record type, `runSummary`. |
| `status` | Run outcome: `SUCCEEDED` or `FAILED`. |
| `runStatus` | Canonical run status; matches `status`. |
| `dataStatus` | Dataset completeness: `COMPLETE`, `PARTIAL`, `NO_RESULTS`, or `FAILED`. |
| `itemCount` | Game rows saved to the dataset. |
| `uniqueAppIds` | Distinct app IDs among the saved rows. |
| `pagesScraped` | Search pages processed. |
| `requestCount` | Public requests attempted. |
| `responseCount` | Public responses received. |
| `failedRequestCount` | Requests that failed before a usable response. |
| `diagnosticCount` | Operational issues recorded outside the dataset. |
| `recordsStored` | Complete records saved to the dataset. |
| `searchQuery` | Search term used for the run. |
| `sortBy` | Sort parameter used for the run. |
| `maxItems` | Configured item cap. |
| `fixtureMode` | Whether a bundled QA fixture was used. |
| `sourceWebsite` | Steam Store source website. |
| `sourceEndpoint` | Public search endpoint. |
| `includeDiagnostics` | Whether diagnostic detail was retained for the run. |
| `outputWriteFailureCount` | Summary writes that failed. |
| `completedAt` | UTC summary creation time. |

| Status | Data status | Meaning |
| --- | --- | --- |
| `SUCCEEDED` | `COMPLETE` | Games were saved without an extraction problem. |
| `SUCCEEDED` | `PARTIAL` | Games were saved, but a later problem prevented a complete run. Saved rows remain available. |
| `SUCCEEDED` | `NO_RESULTS` | The search completed cleanly and returned no matching games. |
| `FAILED` | `FAILED` | A fatal error occurred before any usable game was saved. |

Example `OUTPUT` from the 2026-10-25 run:

```json
{
  "recordType": "runSummary",
  "status": "SUCCEEDED",
  "runStatus": "SUCCEEDED",
  "dataStatus": "COMPLETE",
  "itemCount": 2,
  "uniqueAppIds": 2,
  "pagesScraped": 1,
  "requestCount": 2,
  "responseCount": 2,
  "failedRequestCount": 0,
  "diagnosticCount": 0,
  "recordsStored": 2,
  "searchQuery": "portal",
  "sortBy": "Review_Score_DESC",
  "maxItems": 2,
  "fixtureMode": false,
  "sourceWebsite": "https://store.steampowered.com/",
  "sourceEndpoint": "https://store.steampowered.com/search/",
  "includeDiagnostics": true,
  "outputWriteFailureCount": 0,
  "completedAt": "2026-10-25T21:13:18.155Z"
}
```

### Coverage and limitations

The Actor reads the public Steam Store **game** search page (`category1=998`). It does not crawl every Store category, follow app pages for extra details, log in, use a proxy, or bypass access controls. Requests are direct HTTPS calls with a robots preflight, bounded same-host redirects, a response-size cap, serial delays, and transient-only retries. Prices are display strings for the storefront returned to this request, not normalized currency amounts; `originalPrice` and `discountPercent` appear only when a discount is shown. Review labels and positions reflect the Store response at collection time. Empty or unobserved values are omitted, and failures never create diagnostic or placeholder dataset rows.

### Usage and support

Run cost depends on Apify compute and the number of search pages requested. Start with a small `maxItems`, inspect the dataset and `OUTPUT`, then raise the cap or widen the query. See the Actor's Pricing tab for current account rates. Use the [Actor Issues page](https://apify.com/w3crawler/steam-game-scraper/issues) to report a problem. Include the run ID, the input used, and the run summary; do not include tokens, cookies, or private data. This Actor is not affiliated with Valve or Steam. Use it only for public data and in accordance with Steam's terms, robots guidance, and applicable law.

# Changelog

This Actor's version history is a separate document: https://apify.com/w3crawler/steam-game-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

Public Steam Store search text; empty text lists games using the selected sort.

## `query` (type: `string`):

Compatibility alias for searchQuery.

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

Official Steam search sort parameter.

## `maxItems` (type: `integer`):

Maximum unique public game rows to store.

## `delayMs` (type: `integer`):

Minimum serial delay between live Steam requests.

## `maxRequestRetries` (type: `integer`):

Bounded retries for transient responses only.

## `timeoutMs` (type: `integer`):

Maximum time allowed for one public Steam response.

## `maxResponseBytes` (type: `integer`):

Hard cap for each response and local fixture.

## Actor input object example

```json
{
  "searchQuery": "",
  "sortBy": "Review_Score_DESC",
  "maxItems": 50,
  "delayMs": 750,
  "maxRequestRetries": 1,
  "timeoutMs": 30000,
  "maxResponseBytes": 5000000
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (type: `string`):

Run status and counters stored by the Actor.

## `sourceMetadata` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/steam-game-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/steam-game-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 '{}' |
apify call w3crawler/steam-game-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,w3crawler/steam-game-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/kdE2ss05APfYhLgu3/builds/OzYzZm0aSSdiod49T/openapi.json