# Steam store games - search, details, prices (public store APIs) (`retrainmap/steam-games`) Actor

Search the Steam store by term or appid; one row per app from Steam's public store endpoints: appid, name, type, price (list, final, discount, currency for your country), release date, developers, publishers, genres, categories, platforms, Metacritic, recommendations, description, image, store URL.

- **URL**: https://apify.com/retrainmap/steam-games.md
- **Developed by:** [RetrainMap Team](https://apify.com/retrainmap) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Steam store games — search, details, prices (public store APIs)

One row per Steam app found by your search terms or given by appid — appid, name, type
(game / dlc / demo / music / …), free flag, price (list, final, discount % and currency for
the country you choose), release date, developers, publishers, genres, categories,
platforms, Metacritic score and URL, recommendation count, short description, header
image and store URL. Read from Steam's own public store endpoints — no login, no Steam
Web API key, no scraping of HTML pages beyond the store's search list.

**The default input (term `farming`, US prices, 100 apps) succeeds within 5 minutes
(about 2.5 minutes at the default 1.5 s spacing) and returns rows** — Apify auto-tests it
daily.

### Data source and status

| | |
|---|---|
| Publisher | Valve Corporation (Steam store) |
| Endpoints | `store.steampowered.com/search/results/?json=1` (store search list, 50 per page, apps only) and `store.steampowered.com/api/appdetails?appids=<id>&cc=<country>` (one app per call, the full record) — both public, undocumented but stable for years; `storesearch` is not used because it is capped at 10 results per term |
| Rate | Steam throttles `appdetails` at roughly **200 calls per 5 minutes per IP**; the Actor spaces calls 1.5 s apart by default and waits 60 s when Steam answers 429 or 403 |
| Refresh cadence | Live on every run; prices and discounts are what the store serves for `country_code` at `fetched_at` |
| Terms | Steam store content is Valve's and its partners'; use of the store is subject to the Steam Subscriber Agreement (https://store.steampowered.com/subscriber\_agreement/). This Actor reads only what the public store serves to any visitor and copies no images — `header_image` is a URL |
| Known caveats | Apps Steam answers `success: false` for (unknown, delisted, region-locked, age-gated in some regions) are skipped and listed in `RUN_SUMMARY.unavailable_appids`; `price_*` are null for free and unreleased apps; `metacritic_score` and `recommendations` are null when Steam has none; packages and bundles in the search list are skipped (apps only); the search list order is Steam's, so "relevance" can shift between runs |

Honesty note: the rows are Steam's own `appdetails` fields flattened — prices are the
store's integer minor units ÷ 100, nothing is inferred or estimated, and a run stops with
an error rather than guess when the endpoints' shape changes.

Identification: the requests carry a product-token User-Agent and the operator's
contact address in the standard `From:` header (RFC 9110 §10.1.2).

### Input

| Field | Type | Meaning |
|---|---|---|
| `search_terms` | array | Store search terms; each paged 50 at a time until `max_records` |
| `app_ids` | array | Optional appids fetched first (e.g. `620`) |
| `country_code` | string | Two-letter store region for prices, default `us` |
| `sort` | select | `relevance` (default), `released_desc`, `released_asc`, `name_asc`, `price_asc`, `price_desc`, `reviews_desc` |
| `max_records` | integer | Default 100, at most 2,000 (≈ 25 min per 1,000) |
| `request_interval_ms` | integer | Default 1500 (floor 1000) |
| `contact_email` | string | Sent in the `From:` header |

Example — best-reviewed roguelikes with UK prices, plus Portal 2 and Dota 2 by id:

```json
{ "search_terms": ["roguelike"], "app_ids": ["620", "570"], "country_code": "gb", "sort": "reviews_desc", "max_records": 40 }
```

### Output (dataset row)

`appid`, `name`, `type`, `is_free`, `price_initial`, `price_final`, `discount_percent`,
`currency`, `price_final_formatted`, `country_code`, `release_date` (Steam's display string,
e.g. `Oct 10, 2007`), `coming_soon`, `developers`, `publishers`, `genres`, `categories`,
`platforms` (`windows` / `mac` / `linux`), `metacritic_score`, `metacritic_url`,
`recommendations`, `required_age`, `short_description` (≤ 3,000 chars, HTML stripped),
`header_image` (URL), `website`, `parent_appid` (for DLC / soundtracks), `store_url`,
`matched_term`, `fetched_at`, `source`.

A run summary (terms and Steam's own result totals, candidates, rows, unavailable appids,
requests, throttle waits, whether the pay-per-event budget stopped the run) is stored as
`RUN_SUMMARY` in the run's key-value store.

### Pricing (pay per event)

| Event | Price |
|---|---|
| `run-start` — once per run | $0.10 |
| `record` — per app row written | $0.005 |

The default pull (100 apps) costs at most $0.60; 1,000 apps cost $5.10. Rows stop when
your run's maximum charge is reached; the run summary says so.

### Operator

Steelyard Ventures LLC (RetrainMap) — info@steelyardclinical.com. Not affiliated with
Valve Corporation or Steam. The Actor writes only to its own dataset and key-value store;
it stores no credentials and sends nothing else.

# Actor input Schema

## `search_terms` (type: `array`):

Store search terms, e.g. farming simulator, roguelike, portal. Each term is paged 50 results at a time until max\_records is reached. Empty search terms are allowed when app\_ids are given.

## `app_ids` (type: `array`):

Optional Steam appids to fetch directly (the number in store.steampowered.com/app/<id>/), e.g. 620 for Portal 2. Fetched before the search results.

## `country_code` (type: `string`):

Two-letter country for the store region and currency: us (USD, default), gb (GBP), de (EUR), jp (JPY), br (BRL) ...

## `sort` (type: `string`):

Order of the store search results before the cut at max\_records.

## `max_records` (type: `integer`):

Stop after this many apps. Each app is one appdetails request at request\_interval\_ms; 100 apps take about 2.5 minutes, 1,000 about 25 minutes.

## `request_interval_ms` (type: `integer`):

Politeness delay towards store.steampowered.com (floor 1000 ms). Below about 1,500 ms Steam starts answering 429 after ~200 calls; the Actor then waits 60 s.

## `contact_email` (type: `string`):

Sent in the standard From: request header so the data owner can reach the operator (RFC 9110 s10.1.2).

## Actor input object example

```json
{
  "search_terms": [
    "farming"
  ],
  "country_code": "us",
  "sort": "relevance",
  "max_records": 100,
  "request_interval_ms": 1500,
  "contact_email": "info@steelyardclinical.com"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Steam app: appid, name, type, price, release date, developers, publishers, genres, categories, platforms, Metacritic score, recommendations, description, header image, store URL.

## `results_csv` (type: `string`):

The same rows as a CSV file.

# 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 = {
    "search_terms": [
        "farming"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("retrainmap/steam-games").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 = { "search_terms": ["farming"] }

# Run the Actor and wait for it to finish
run = client.actor("retrainmap/steam-games").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 '{
  "search_terms": [
    "farming"
  ]
}' |
apify call retrainmap/steam-games --silent --output-dataset

```

## MCP server setup

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

```

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/f5i6DcEoe5KP6aVB3/builds/Yc3kcjEg98cUQdQjl/openapi.json