# Steam Price Scraper - Regional Game Prices (`dataio/steam-regional-pricing-intelligence`) Actor

Scrape Steam game prices across up to 52 markets at once, converted to USD with the gap to the US price, discount status, review counts behind the rating, and the markets where a game is not sold at all. Regional pricing intelligence for publishers. No API key.

- **URL**: https://apify.com/dataio/steam-regional-pricing-intelligence.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** E-commerce, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 game rows

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

### What does Steam Price Scraper do?

The price of a game on **every Steam market at once**, converted to USD,
with the gap to the US price — plus the review counts the store rating
hides, and the markets where the game is not sold at all.

Steam's regional pricing is the widest of any major platform. The store
API answers for one country per request, so asking the obvious question —
"what does this cost in Brazil, Turkey and India" — means twenty requests
and a manual reconciliation with exchange rates.

No API key. No account.

***

### The spread is not small

Measured across 16 markets:

**Cyberpunk 2077** — **121% apart**

| Market | Local price | USD | vs US |
|---|---|---|---|
| India | ₹2,999 | **$31.23** | **−48%** |
| Ukraine | 1 399₴ | $31.36 | −48% |
| Brazil | R$ 199,90 | $38.81 | −35% |
| United States | $59.99 | $59.99 | — |
| United Kingdom | £49.99 | $67.11 | +12% |
| Germany | 59,99€ | **$69.01** | **+15%** |

**Red Dead Redemption 2** — **94% apart**, from $41.50 in China to $80.53
in the United Kingdom.

Across the whole run, the same six games spanned **$29.60 to $80.53** —
a 172% spread.

And **Russia returned no price for any of the six**. Steam stopped selling
there, and the Actor reports that as a market withdrawal rather than
letting the row vanish.

***

### The three things this does that the source does not

**1. One row per game and per market, in USD.**

₹2,999 and 59,99€ are not comparable until they are. Converted at the
day's rates across 166 currencies, with `priceVsUsPct` giving the gap to
the US price at a glance. The local price and currency are always kept
alongside — conversion never replaces the source figure.

**2. The review counts behind the verdict.**

Steam shows "Very Positive" without saying what it covers. Dota 2's
verdict rests on **2,780,059 reviews — 2,237,744 positive, 542,315
negative, 80.5% positive**. That ratio is computed here; the store never
shows it.

**3. It makes the whole thing practical.**

`appdetails` rejects multiple app IDs with HTTP 400 — **unless** you pass
`filters=price_overview`, and then it accepts dozens at once. That single
undocumented quirk turns 1,000 requests into 70 for fifty games across
twenty markets, which is the difference between a usable Actor and one
that spends half an hour being rate-limited.

***

### Field coverage

Measured on 82 available rows across 17 markets.

| Field | Coverage |
|---|---|
| `name`, `developers`, `publishers`, `genres` | 100% |
| `releaseDate`, `recommendations` | 100% |
| `reviewScore`, `totalReviews`, `positiveRatioPct` | 100% |
| `metacriticScore`, `achievementCount` | 79% |
| `price`, `priceUsd`, `currency` | every paid game |

`price` is empty for free-to-play titles, which is correct — they have no
price. Use **Paid games only** when comparing pricing.

***

### What it is for

- **Pricing strategy.** Set regional prices from what comparable titles
  actually charge there, not from a currency conversion of your US price.
- **Key reselling and grey-market analysis.** The markets with the deepest
  discounts are the ones grey-market keys come from.
- **Publisher and competitor tracking.** A whole catalogue, with review
  ratios and Metacritic side by side.
- **Market entry and withdrawal.** Which markets a publisher skipped, and
  which they have left.
- **Sale monitoring.** Discounts are regional; a sale in Brazil is not a
  sale in Japan.

Three dataset views ship with the Actor: **Price by market**,
**Reception** and **Catalogue**.

***

### Limits

Stated plainly, because they affect what you can conclude.

- **Steam rate-limits firmly.** Requests are paced and retried with a long
  backoff on HTTP 429. Large runs take minutes, not seconds.
- **Exchange rates are same-day.** A price set at ₹2,999 does not move
  when the rupee does, so part of any spread is currency drift rather
  than deliberate pricing. `priceVsUsPct` is a comparison aid, not an
  accounting figure.
- **Prices exclude local tax.** Steam displays tax-inclusive prices in
  some regions and not others, which is Valve's behaviour, not ours.
- **Review counts are lifetime and global**, not per market. Only the
  price varies by country; the reception figures are the same on every
  row for a given game.
- **Some games are region-locked rather than absent.** A missing price can
  mean "not sold here" or "sold only as part of a bundle". The row says
  the price is unavailable, not why.
- **Release dates come as Steam writes them** — "Dec 9, 2020", "Q1 2027",
  or blank. `releaseDate` is the ISO version when it can be parsed;
  `releaseDateRaw` always carries the original.
- **DLC and bundles are separate app IDs.** A base game's price is not the
  cost of owning everything.

***

### Use Steam Price Scraper as an API

Call it from your own code with the Apify client, here in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/steam-regional-pricing-intelligence").call(run_input={
    'appIds': ['1091500', '271590', '292030'],
    'countries': ['us', 'gb', 'de', 'br', 'in', 'tr', 'jp'],
    'maxItems': 800,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works from JavaScript, Make, Zapier, n8n, and from AI agents through the Apify MCP server.

### Other actors you might like

- [App Store Price Scraper](https://apify.com/DataIO/app-store-price-intelligence): Compare by Country
- [App Store Reviews Scraper](https://apify.com/DataIO/app-store-reviews-by-country-version): By Country & Version
- [Steam Reviews Scraper](https://apify.com/DataIO/steam-reviews-playtime-scraper): With Playtime Data

### FAQ

#### Is it legal to use this data?

The actor reads public data from its official source, without logging in and without bypassing any access control. What you do with the data, for example contacting people listed in it, is your responsibility under the laws that apply to you, such as GDPR in Europe.

#### Can I run it on a schedule?

Yes. Create a schedule in Apify Console, daily or weekly for example, and each run delivers a fresh dataset, which you can send by email, webhook or integration.

#### Can AI agents use it?

Yes. It is available through the Apify MCP server, and every input field is described in its input schema, so an agent can call it directly.

### Sources

Steam's public store API (`appdetails`, `appreviews`, `storesearch`) and
[open.er-api.com](https://open.er-api.com) for exchange rates. Both
public, no authentication. This Actor is not affiliated with Valve.

# Actor input Schema

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

The number in a Steam URL: store.steampowered.com/app/1091500/ is 1091500. Up to 200 games per run.

## `searchTerm` (type: `string`):

Game name, if you do not have the IDs. Returns Steam's own store search results.

## `countries` (type: `array`):

Two-letter country codes. This is the whole point: measured on Cyberpunk 2077, the price ran from $31 in India to $69 in Germany — 121% apart. Steam's regional pricing is far wider than any other platform's.

## `paidOnly` (type: `boolean`):

Free-to-play titles carry no price and dilute a pricing comparison.

## `onSaleOnly` (type: `boolean`):

Keeps only games currently discounted in that market. Discounts are regional too — a sale in Brazil is not a sale in Japan.

## `minPositiveRatio` (type: `integer`):

0 to 100. Steam shows 'Very Positive' without saying what that covers; this filters on the actual computed ratio.

## `includeUnavailable` (type: `boolean`):

On by default, and deliberately: Steam no longer sells in Russia, and a silently missing row would read as a collection error rather than a market withdrawal. Those rows are not charged.

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

One row per game per market.

## Actor input object example

```json
{
  "appIds": [
    "1091500",
    "271590",
    "292030"
  ],
  "countries": [
    "us",
    "gb",
    "de",
    "br",
    "in",
    "tr",
    "jp",
    "cn"
  ],
  "paidOnly": false,
  "onSaleOnly": false,
  "includeUnavailable": true,
  "maxItems": 1000
}
```

# Actor output Schema

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

Every row produced by the run, in JSON.

# 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 = {
    "appIds": [
        "1091500",
        "271590",
        "292030"
    ],
    "countries": [
        "us",
        "gb",
        "de",
        "br",
        "in",
        "tr",
        "jp",
        "cn"
    ],
    "maxItems": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/steam-regional-pricing-intelligence").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 = {
    "appIds": [
        "1091500",
        "271590",
        "292030",
    ],
    "countries": [
        "us",
        "gb",
        "de",
        "br",
        "in",
        "tr",
        "jp",
        "cn",
    ],
    "maxItems": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/steam-regional-pricing-intelligence").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 '{
  "appIds": [
    "1091500",
    "271590",
    "292030"
  ],
  "countries": [
    "us",
    "gb",
    "de",
    "br",
    "in",
    "tr",
    "jp",
    "cn"
  ],
  "maxItems": 1000
}' |
apify call dataio/steam-regional-pricing-intelligence --silent --output-dataset

```

## MCP server setup

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

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/Aey4eR28XUmkHAxWj/builds/hxirAH6sf1as8hPmc/openapi.json