Steam store API

Gaming · v1.1.0 · steam

$0.0008 / app

$0.64 / 1K · pay per delivered app

A Steam store API with two modes over Steam's public endpoints. Pass a query to search games and get appid, name, price with any discount, Metacritic score and platforms back; pass a list of appids or store URLs for the full store record — type, price with any discount, developers and publishers, genres and categories, release date, Metacritic score, recommendation count, platforms and the description. No Steam Web API key.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0008 per delivered app · $2 free every month · Failed runs never billed

What it does

What a Steam store API does

This is store data — not the Steam Web API and not the community market: no player stats or achievements, no item and skin prices, just the catalog record a store page shows. Search resolves titles to appids, then detail mode turns those appids into typed rows with pricing, ratings and metadata already separated into fields.

Because it reads Steam's own store search and appdetails endpoints, there is no key to register, and the price is the storefront's, so country changes both the currency and the amount. One request handles a batch of appids, and platforms, genres and categories come back as arrays rather than a comma-joined string to split later.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	no	Search term (search mode). Use this OR app_ids.
`app_ids`	array	no	Steam appids or store URLs for full detail. Use this OR query.
`country`	string	no	Storefront country for pricing (default us).
`include_reviews`	boolean	no	Detail mode: also read Steam's review verdict and totals for each app (one small extra request per app).
`max_results`	integer	no	How many apps to deliver at most (1–50). You pay only for delivered apps.

Outputs — 41 fields, one row per app

What one app looks like

Every delivered app carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position.
`app_id`	string	Steam appid.
`name`	string · nullable	Game/app title.
`type`	string · nullable	game, dlc, demo… (detail mode).
`is_free`	boolean	Free-to-play (detail mode).
`price`	number · nullable	Final price.
`price_formatted`	string · nullable	Price as shown.
`discount_pct`	integer · nullable	Discount %.
`currency`	string · nullable	Price currency.
`developers`	string[]	Developers (detail mode).
`publishers`	string[]	Publishers (detail mode).
`genres`	string[]	Genres (detail mode).
`categories`	string[]	Store categories (detail mode).
`release_date`	string · nullable	Release date as shown (detail mode).
`metacritic`	integer · nullable	Metacritic score.
`recommendations`	integer · nullable	Total recommendations (detail mode).
`platforms`	string[]	windows/mac/linux.
`header_image`	string · nullable	Header image URL.
`icon`	string · nullable	Icon URL (search mode).
`short_description`	string · nullable	Short description (detail mode).
`url`	string	Store page URL.
`logo`	string · nullable	Capsule image (search rows).
`coming_soon`	boolean · nullable	Not yet released (detail rows).
`required_age`	integer · nullable	Minimum age (detail rows).
`list_price`	number · nullable	Price before discount.
`controller_support`	string · nullable	full / partial.
`review_summary`	string · nullable	Steam's review verdict (Very Positive, Mixed…) — detail rows.
`reviews_total`	integer · nullable	Total user reviews.
`reviews_positive`	integer · nullable	Positive reviews.
`reviews_negative`	integer · nullable	Negative reviews.
`reviews_positive_pct`	number · nullable	Share of positive reviews (%).
`website`	string · nullable	Official website.
`languages`	string[] · nullable	Supported languages.
`dlc_count`	integer · nullable	Number of DLCs.
`achievements`	integer · nullable	Number of achievements.
`age_rating`	string · nullable	ESRB / PEGI rating.
`content_notes`	string · nullable	Mature-content note from the store page.
`screenshots`	string[] · nullable	Screenshot URLs (up to 5).
`trailer`	string · nullable	First trailer stream URL.
`metacritic_url`	string · nullable	Metacritic page.
`support_url`	string · nullable	Support page.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/steam/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/steam/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"portal","max_results":10}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/steam/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "portal",
        "max_results": 10
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/steam/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"portal","max_results":10}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the steam collector with query="portal" and max_results=10

Example response

POST /v1/scraper/collectors/steam/run

$ curl $QD/steam/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "portal", "max_results": 10}'
{ "status": "done", "count": 10,
  "results": [
    {
      "app_id": "…",
      "name": "…",
      "type": "…",
      "is_free": false } ],
  "cost": 0.008 }
# 10 apps × $0.0008 · nothing delivered, nothing charged

Try it

Steam game data, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Steam store API: from query, QuanticData reads the Steam store page and returns one row per app with name, is_free and price, at $0.0008 per delivered app. — You send query and app_ids; the run goes out through a residential exit and comes back as apps with rank, app_id and name — 41 fields on every row — and you are billed $0.0008 for each app actually delivered, nothing for a run that delivers none.

$0.0008 / app2,500 apps on the free $2 every month

Semantic inputquery, app_ids, country — no URL lists

Up to 50apps per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

Steam store API pricing

$0.0008 per delivered app. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,500 apps before you spend anything.

$0.0008per delivered app$0.64 per 1,000 delivered apps

2,500 appson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the Steam store API

Three shapes of work this endpoint was designed around.

Catalog building

Search a term, collect the appids, then resolve them to full records to seed a games dataset.

Price and discount tracking

Read price, discount_pct and currency per appid for a watchlist, per storefront via country.

Ratings benchmarking

Compare Metacritic score and recommendation count across a set of titles in one detail run.

Steam store API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Scope	Steam Web API — players and stats	Store catalog — price, genres, Metacritic
Key	Steam Web API key required	Keyless public store endpoints
Arrays	Comma-joined strings to parse	Genres, categories and platforms as arrays

What people search for

Live autocomplete demand around Steam game data, pulled with our own Keyword ideas collector.

Steam store API: the POST to the steam collector, 10 apps delivered and the bill, 10 × $0.0008 = $0.008 in usage.cost_usd; zero apps would cost $0. — The same call you would paste into a terminal: a Bearer key, query, app_ids and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many apps arrived and usage.cost_usd is $0.008, which is 10 × $0.0008. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Steam store API.

Something else? Ask us

Do I need a Steam Web API key?

No. This reads Steam's public store search and appdetails endpoints, which need no key — unlike the Steam Web API, which serves the player, achievement and inventory data this collector does not touch.

Is this the community market for skins and items?

No. It returns the store catalog record for games and DLC — price, genres, Metacritic, platforms — not Community Market listings or item prices, which are a separate Steam surface.

How do search and detail modes relate?

Search takes a query and returns appid, name, price and platforms so you can find titles; detail takes app_ids (or store URLs) and returns the full record. Chain them: search to discover appids, then detail to enrich them.

Is there a free Steam store API?

Every account gets $2 of credit every month with no card, which is about 2,500 delivered apps on this endpoint at $0.0008 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0008. A run capped at 50 apps — the maximum for this collector — costs $0.04 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Steam store API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (Steam store page) turn into clean JSON with the fields name, is_free and price; 41 fields on every row.