# Steam Game Price Tracker (`trovevault/steam-game-price-tracker`) Actor

Scrape current Steam prices, active sale discounts, user review scores, Metacritic scores, and game metadata for any list of games. Accepts game titles or numeric Steam App IDs. Use it to monitor Steam sales, build game deal alerts, benchmark pricing across regions, or enrich a game catalog.

- **URL**: https://apify.com/trovevault/steam-game-price-tracker.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Developer tools, News, Other
- **Features:** Limited permissions
- **Stats:** 9 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.28 / 1,000 games

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Price Tracker — Prices, Discounts & Reviews

Scrape current Steam prices, active sale discounts, user review scores, Metacritic scores, and game metadata for any list of games. Accepts game titles or numeric Steam App IDs. No API key required.

Use it to monitor Steam sales, build game deal alerts, benchmark pricing across regions, or enrich a game catalog with live store data.

***

### What does Steam Game Price Tracker extract?

For each game you provide, this Actor:

- Looks up the Steam App ID by title (or uses the App ID directly)
- Fetches the current price and any active discount from the Steam Store API
- Returns the review score (% positive), review summary label, and total review count
- Returns the Metacritic score, release date, developer, publisher, and genre list
- Supports regional pricing — results reflect the correct local price and currency for any country

All data comes from Steam's public store and review APIs. No login, no API key, no proxies required.

***

### What data does Steam Game Price Tracker return?

| Game info | Price & discounts | Reviews & scores |
|---|---|---|
| 📝 Official game title | 💰 Current price | ⭐ Review score (% positive) |
| 🔗 Steam store URL | 🏷️ Original price | 💬 Review summary label |
| 🎮 Steam App ID | 🔖 Discount percentage | 💬 Total review count |
| 👨‍💻 Developer | 💱 Currency code | 🎯 Metacritic score |
| 🏢 Publisher | 🆓 Free-to-play flag | 📅 Release date |
| 🎭 Genre tags | — | — |

***

### What can I do with Steam price data?

#### Track Steam sale prices at scale

Run a list of 50, 100, or 500 games during a Steam seasonal sale and capture the discounted price, original price, and discount percentage for each one in a single run.

#### Build a game deal monitoring pipeline

Schedule this Actor to run daily or weekly. Compare current prices against a baseline to detect new discounts and trigger alerts for price drops. A daily schedule is recommended during seasonal sale periods (Summer Sale, Winter Sale, etc.).

#### Enrich a game database

Append live Steam store data — price, review score, Metacritic score, genres, developer — to an existing list of games. Useful for games journalism, recommendation engines, and market research tools.

#### Regional price benchmarking

Run the same list of games with different country codes (`us`, `gb`, `de`, `br`, `ar`) to compare regional Steam pricing. Argentina and Turkey are commonly cheaper markets — useful for understanding global pricing strategy.

#### Validate free-to-play status

Check a bulk list of games to identify which are currently free-to-play on Steam.

***

### Why use Steam Game Price Tracker instead of alternatives?

| Feature | SteamDB / manual browsing | Steam Game Price Tracker |
|---|---|---|
| Bulk lookup | One game at a time | Any number of games in one run |
| Export formats | Web UI only | JSON, CSV, Excel |
| Regional pricing | Manual country switching | Single `country` input parameter |
| Title resolution | Manual search | Automatic title → App ID lookup |
| Scheduling & alerts | Not available | Apify Scheduler + webhooks |
| API key required | No | No |

***

### How to use Steam Game Price Tracker

1. Add game titles or Steam App IDs to the **Games** input field — one per line
2. Optionally set a **Country** code for regional pricing (default: `us`)
3. Click **Start** — results appear within seconds

***

### How much will it cost?

Steam Game Price Tracker uses Steam's public APIs — no browser rendering, no proxies required.

**Typical costs:**

- 10 games: < $0.01
- 100 games: < $0.05
- 500 games: ~$0.10

The actor waits 600ms between requests to respect Steam's rate limits. A list of 100 games takes approximately 2 minutes.

**Cost tips:**

- Use App IDs instead of titles to skip the title resolution step and slightly reduce cost
- For large lists, run during off-peak hours to avoid any temporary Steam API throttling

See the [Apify pricing page](https://apify.com/pricing) for full pricing details.

***

### How does Steam Game Price Tracker work?

1. **Title resolution** — for each game title, the actor queries Steam's autocomplete search API to find the corresponding App ID. Numeric App IDs skip this step.
2. **Store API call** — fetches price, discount, release date, developer, publisher, and genre data from `store.steampowered.com/api/appdetails`.
3. **Review API call** — fetches review summary and count from `store.steampowered.com/appreviews/{appId}`.
4. **Regional pricing** — the `country` parameter is passed to Steam's API, which returns prices in the local currency.
5. **Rate limiting** — a 600ms delay between requests keeps the actor within Steam's public API limits.

***

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `games` | String list | Yes | Game titles or numeric Steam App IDs |
| `country` | String | No | Two-letter country code for pricing (default: `us`) |

**Accepted country codes (examples):** `us`, `gb`, `de`, `fr`, `br`, `ar`, `tr`, `au`, `ca`, `jp`

#### Input examples

**Game titles:**

```
Cyberpunk 2077
Elden Ring
Hollow Knight
Counter-Strike 2
```

**Steam App IDs:**

```
1091500
1245620
367520
730
```

**Mixed:**

```
Cyberpunk 2077
1245620
Hollow Knight
```

***

### Output fields

| Field | Description |
|---|---|
| `query` | Your original input — game title or App ID |
| `appId` | Steam numeric App ID |
| `title` | Official game title as shown on Steam |
| `url` | Steam store page URL |
| `isFree` | `true` for free-to-play games |
| `currency` | Currency code for all price fields (e.g. `USD`, `GBP`, `EUR`) |
| `currentPrice` | Current price after any active discount. `0` for free games. |
| `originalPrice` | Price before discount. `null` if no sale is active. |
| `discountPercent` | Active discount in percent. `0` if not on sale. |
| `reviewScore` | Percentage of positive reviews (0–100). `null` if no reviews yet. |
| `reviewSummary` | Steam review label: `Overwhelmingly Positive`, `Very Positive`, `Mixed`, `Mostly Negative`, etc. |
| `totalReviews` | Total number of Steam reviews |
| `metacriticScore` | Metacritic score (0–100). `null` if not available on Steam. |
| `releaseDate` | Release date as shown on the Steam store |
| `developer` | Primary developer |
| `publisher` | Primary publisher |
| `genres` | Array of genre tags from the Steam store |
| `error` | Populated only if the game could not be found or loaded |

***

### Frequently asked questions

**Does this require a Steam API key?**
No. This Actor uses Steam's public store and review APIs which do not require authentication.

**Can I look up games by Steam App ID instead of title?**
Yes. Enter a numeric App ID (e.g. `730`) directly in the games list. This is more reliable than title search for games with ambiguous names.

**What happens with free-to-play games?**
Free-to-play games return `currentPrice: 0`, `isFree: true`, `originalPrice: null`, and `discountPercent: 0`.

**Can I get prices for a specific region or currency?**
Yes. Set `country` to any two-letter ISO country code (e.g. `gb` for British pounds, `de` for euros, `br` for Brazilian reais).

**What if a game is not found?**
The output row will contain the original query and an `error` field. This can happen for DLCs, soundtracks, software, or titles not available in the selected region.

**Is there a rate limit?**
The Actor waits 600ms between games to stay within Steam's rate limits. A list of 100 games takes approximately 2 minutes.

**How do I set up price drop alerts?**
Schedule the actor to run daily, then use an Apify webhook or the Make/Zapier integration to compare the latest dataset with a previous baseline and trigger a notification when `discountPercent > 0` appears on a game that was previously at full price.

**Can I use Steam Game Price Tracker via the Apify API?**
Yes. Use the [Run Actor](https://docs.apify.com/api/v2#/reference/actors/run-collection/run-actor) endpoint with your actor ID and input JSON. Combine with Apify webhooks to build automated deal alert pipelines.

**Can I use Steam Game Price Tracker through an MCP Server?**
Yes. Via the [Apify MCP server](https://mcp.apify.com), you can call this actor from any MCP-compatible AI assistant (Claude, ChatGPT, etc.) to look up game prices in real time from a conversation.

**Is scraping Steam data legal?**
This actor uses Steam's public store and review APIs — the same endpoints the Steam website and Steam app use. Accessing publicly available pricing data is generally permitted. Always review Steam's terms of service for your specific use case.

***

### Related actors

- **[Competitor Intelligence Scraper](https://apify.com/trovevault/competitor-intelligence-scraper---funnel-pricing-conversion)** — scrape competitor pricing models, funnel structure, and conversion tactics for SaaS and e-commerce
- **[Movie Box Office Tracker](https://apify.com/trovevault/movie-box-office-tracker)** — box office performance data for any film: budget, gross, ROI, and distributor

***

### Changelog

#### 2026-03-09 — v0.1.0

- Initial release
- Game lookup by title or Steam App ID
- Current price, discount, review score, Metacritic, developer, publisher, genres
- Regional pricing via country code

***

### Your feedback

Found a bug or have a feature request? [Open an issue](https://github.com/apify/apify-community/issues) or contact us through the Apify platform. Your feedback helps improve this actor for everyone.

# Actor input Schema

## `games` (type: `array`):

List of game titles or numeric Steam App IDs to look up. You can mix titles and IDs in the same list. To find a game's App ID, open its Steam store page — the number in the URL is the ID (e.g. store.steampowered.com/app/730/ → ID is 730). Using the App ID is more reliable than the title for exact matches.

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

Two-letter ISO 3166-1 country code for regional pricing and currency. Examples: us (USD), gb (GBP), de (EUR), fr (EUR), au (AUD), br (BRL), jp (JPY). Default: us

## `datasetId` (type: `string`):

ID of an existing Apify dataset to push results into in addition to the default dataset. Useful for combining results from multiple runs or integrating with downstream actors.

## `runId` (type: `string`):

ID of a previous actor run to associate this run with. Used for chaining actors in multi-step pipelines.

## Actor input object example

```json
{
  "games": [
    "Cyberpunk 2077",
    "730",
    "Elden Ring"
  ],
  "country": "us"
}
```

# Actor output Schema

## `dataset` (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 = {
    "games": [
        "Cyberpunk 2077",
        "730",
        "Elden Ring"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/steam-game-price-tracker").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 = { "games": [
        "Cyberpunk 2077",
        "730",
        "Elden Ring",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/steam-game-price-tracker").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 '{
  "games": [
    "Cyberpunk 2077",
    "730",
    "Elden Ring"
  ]
}' |
apify call trovevault/steam-game-price-tracker --silent --output-dataset

```

## MCP server setup

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

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/KcBNH3GT65kp4gZEg/builds/qjU4tl9qIpamqsP0q/openapi.json