# Steam Game Specs, Pricing & Media Extractor (`dataspryva/steam-game-specs-pricing-and-media-extractor`) Actor

Collect per-game data from Steam store pages by URL or name search: pricing, system requirements, genres, tags, screenshots, trailers, DLC, review scores and Steam Awards.

- **URL**: https://apify.com/dataspryva/steam-game-specs-pricing-and-media-extractor.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** E-commerce, Automation, Videos
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Game Specs, Pricing & Media Extractor

Steam shows each game through a store page plus an underlying app-details feed. This actor collects both for every title you give it and returns one clean record with the commercial, technical and promotional data a catalog needs: store pricing and package options, system requirements, platform and language support, screenshots and trailers, DLC, tags, regional age ratings, review totals and Metacritic information.

### Ways to select games

- **Store URLs** — paste full Steam store links, including age-gated links.
- **App IDs** — send numeric IDs or store links in any mix.
- **Name search** — search Steam by title and collect the top matches.
- **Steam charts** — walk top sellers, new releases, current specials, coming soon or weeklong deals.

All four paths feed the same detail collector, and duplicate App IDs are removed across the whole run. Add the optional app-type filter when you only want games, DLC, demos, software, video, music, series or episodes.

### What each record contains

| Group | Fields |
| --- | --- |
| Identity | `appId`, `appType`, `title`, `url`, `releaseDate`, `releaseDateIso`, `comingSoon`, `requiredAge`, `isFree`, `controllerSupport` |
| Pricing | `currency`, `priceInitial`, `priceFinal`, `priceInitialFormatted`, `priceFormatted`, `discountPercent`, `packages`, `packageGroups` |
| Descriptions | `shortDescription`, `detailedDescription`, `aboutTheGame`, `pressQuotes` |
| Artwork | `headerImage`, `capsuleImage`, `capsuleImageV5`, `backgroundImage`, `backgroundRawImage` |
| Media | `screenshots`, `screenshotThumbnails`, `trailers` (with HLS, DASH, MP4 and WebM links when Steam publishes them) |
| Requirements | `windowsRequirements`, `macRequirements`, `linuxRequirements` (`minimum` / `recommended`) |
| Support matrix | `platforms`, `supportedLanguages`, `fullyAudioLanguages` |
| Taxonomy | `genres`, `genreIds`, `categories`, `categoryIds`, `tags` |
| Credits and support | `developers`, `publishers`, `website`, `supportInfo` |
| Reviews | `totalReviews`, `positiveReviews`, `negativeReviews`, `reviewScore`, `reviewScorePercent`, `positiveReviewPercent`, `recommendationsTotal`, `metacriticScore`, `metacriticUrl` |
| Extras | `totalAchievements`, `dlcCount`, `dlcAppIds`, `dlc`, `contentDescriptors`, `contentDescriptorNotes`, `ratings`, `legalNotice`, `similarGames`, `awards`, `scrapedAt` |

Fields Steam genuinely does not publish for a particular app are left out of that record rather than filled with empty placeholders. That keeps every value real and makes schemas easier to validate.

`reviewScorePercent` is Steam's legacy 0–9 review-band index kept for backward compatibility; `positiveReviewPercent` is the actual share of positive reviews.

### Input reference

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `mode` | select | `urls` | `urls`, `appIds`, `search` or `browse`. |
| `startUrls` | URL list | – (prefill: Dota 2 page) | Steam store links for URL mode. |
| `appIds` | string list | – | Numeric App IDs or store links for ID mode. |
| `searchQueries` | string list | – | Game names for search mode. |
| `browseCategory` | select | `topSellers` | Chart used by browse mode. |
| `appType` | select | all | Keep only one Steam app type: game, DLC, demo, software, video, music, series, episode, hardware, mod or advertising. |
| `maxItems` | integer | `10` | Maximum game records to return (1–1000). |
| `maxResultsPerQuery` | integer | `10` | Search matches considered per name (1–100). |
| `country` | select | `us` | Steam storefront used for prices, availability and ratings. |
| `language` | select | `english` | Language for descriptions, requirements and review labels. |
| `includeReviews` | boolean | `true` | Fetch the current review summary. |
| `includeSimilarGames` | boolean | `true` | Include Steam's "More like this" games with titles. |

#### URL mode

```json
{
  "mode": "urls",
  "startUrls": [
    { "url": "https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/" },
    { "url": "https://store.steampowered.com/app/1245620/ELDEN_RING/" }
  ],
  "country": "gb",
  "language": "english",
  "maxItems": 2
}
```

#### App ID mode

```json
{
  "mode": "appIds",
  "appIds": ["570", "620", "https://store.steampowered.com/app/292030/"],
  "maxItems": 3
}
```

#### Search mode

```json
{
  "mode": "search",
  "searchQueries": ["Hades II", "Baldur's Gate 3"],
  "maxResultsPerQuery": 3,
  "maxItems": 5,
  "appType": "game"
}
```

#### Chart browsing

```json
{
  "mode": "browse",
  "browseCategory": "newReleases",
  "maxItems": 20,
  "country": "us"
}
```

### Backward compatibility

Existing tasks keep working. `startUrls` remains the native URL list; legacy `urls` and `appId` are mapped to their modern modes, and `gameNames` is mapped to name search. The old input keys are not shown in the form because the current form has clearer mode-based fields.

### Practical notes

- Prices are returned exactly as the chosen storefront reports them. Changing `country` changes both the currency and the available packages.
- `releaseDateIso` is built from Steam's release timestamp, so it stays consistent when you change `country` or `language`; the localized `releaseDate` text is returned alongside it. Year-only and quarter-only dates get no fabricated day.
- The review summary is a live snapshot. Counts move constantly on popular titles.
- Screenshots and trailers are direct Steam CDN links. Some trailer formats are streaming manifests (HLS/DASH) rather than single files; `videoUrl` picks the best published link and the format-specific fields are also included.
- DLC titles and links are read from the store page; `dlcAppIds` comes from the app-details feed. When both sources are present they are aligned by App ID.
- Similar-game titles cost one extra small lookup per recommendation; turn `includeSimilarGames` off for large chart runs if you only need the App IDs.
- No Steam account, cookie, API key or proxy configuration is needed.

### FAQ

**Can I mix URLs, IDs and names in one run?**
One mode runs per execution. Use URL or ID mode for exact titles, or search mode with several names; duplicates are removed automatically inside the chosen mode.

**Why is a price missing on a free game?**
Free titles carry `isFree: true` and zero price fields instead of a paid price block. Steam does not publish a currency price for them.

**Why do some games have no Metacritic fields?**
Steam only links Metacritic for games that have a matching review page. When the link is absent the fields are omitted.

**Does this actor download the videos or screenshots?**
No. It returns their CDN URLs so you can download only the media you need.

**Is this affiliated with Valve or Steam?**
No. This is an independent data tool and is not endorsed by or affiliated with Valve Corporation.

# Actor input Schema

## `mode` (type: `string`):

Pick one lookup method. Steam store URLs, App IDs, keyword search and Steam charts are all supported.

## `startUrls` (type: `array`):

Full Steam store page links, for example https://store.steampowered.com/app/1174180/Red_Dead_Redemption_2/

## `appIds` (type: `array`):

Numeric App IDs or store links. Example: 570 or https://store.steampowered.com/app/570/

## `searchQueries` (type: `array`):

Steam's search is used for each name. The top matches are collected and de-duplicated by App ID.

## `browseCategory` (type: `string`):

Used by Browse Steam charts mode. Top sellers, new releases, current specials, coming soon and weeklong deals are available.

## `appType` (type: `string`):

Keep only one Steam app type in the results.

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

Stop after this many game records. Each record is one Steam app.

## `maxResultsPerQuery` (type: `integer`):

How many Steam search matches to consider for each game name. Used by search mode.

## `country` (type: `string`):

Prices, availability and age ratings come from this Steam storefront.

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

Text language for descriptions, system requirements and review labels.

## `includeReviews` (type: `boolean`):

Collect the current Steam review summary (totals, label and score).

## `includeSimilarGames` (type: `boolean`):

Collect the games Steam recommends in the More like this carousel, with their titles.

## Actor input object example

```json
{
  "mode": "urls",
  "startUrls": [
    {
      "url": "https://store.steampowered.com/app/570/Dota_2/"
    }
  ],
  "browseCategory": "topSellers",
  "appType": "",
  "maxItems": 1,
  "maxResultsPerQuery": 10,
  "country": "us",
  "language": "english",
  "includeReviews": true,
  "includeSimilarGames": false
}
```

# Actor output Schema

## `games` (type: `string`):

Dataset containing one complete record per Steam game or app.

# 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 = {
    "mode": "urls",
    "startUrls": [
        {
            "url": "https://store.steampowered.com/app/570/Dota_2/"
        }
    ],
    "maxItems": 1,
    "includeReviews": true,
    "includeSimilarGames": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/steam-game-specs-pricing-and-media-extractor").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 = {
    "mode": "urls",
    "startUrls": [{ "url": "https://store.steampowered.com/app/570/Dota_2/" }],
    "maxItems": 1,
    "includeReviews": True,
    "includeSimilarGames": False,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/steam-game-specs-pricing-and-media-extractor").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 '{
  "mode": "urls",
  "startUrls": [
    {
      "url": "https://store.steampowered.com/app/570/Dota_2/"
    }
  ],
  "maxItems": 1,
  "includeReviews": true,
  "includeSimilarGames": false
}' |
apify call dataspryva/steam-game-specs-pricing-and-media-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/steam-game-specs-pricing-and-media-extractor"
        }
    }
}
```

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/Pt89mouHFbMvqsm0j/builds/jIWbbsbamxjaHNnmq/openapi.json