# Steam App Lookup — Game Price, Requirements & Metadata API (`accountable_eel/steam-app-lookup`) Actor

Look up games and software on Steam by app ID against Valve's official Store API. Get current and list price, discount percentage, release date, developers, publishers, genres, categories, Metacritic score, review count, and platform support. Pay only for app IDs that resolve to a real listing.

- **URL**: https://apify.com/accountable\_eel/steam-app-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 successful lookups

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?

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 App Lookup

Look up any game or software title on [Steam](https://store.steampowered.com) by app ID
against Valve's own official Store API (`store.steampowered.com/api/appdetails`) — price,
discount, release date, developers, publishers, genres, categories, Metacritic score,
review count, and platform support. No API key, no scraping the storefront pages — this
calls the same free, public JSON endpoint Valve exposes directly.

### Features

- **App ID or store URL input.** Paste a bare app ID (`730`) or a full store URL
  (`https://store.steampowered.com/app/730/CounterStrike_2/`) — either resolves the same
  way.
- **Full pricing detail.** Current price, list price, currency, and discount percentage,
  correctly handling free-to-play titles.
- **Rich metadata.** Developers, publishers, genres, categories, release date,
  Metacritic score, total Steam recommendations, and supported platforms (Windows/Mac/Linux).
- **Bulk-friendly filtering.** Keyword include/exclude, a result cap, and a `testRun` mode
  that processes only the first 5 items before a full run.
- **Pay only for hits.** App IDs that don't resolve to a real listing cost nothing —
  see [Pricing](#pricing).

### How to use Steam App Lookup — Game Price, Requirements & Metadata API

1. **In the Apify Console.** Open the actor page and click **Start** — the `appIds` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~steam-app-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"appIds":["730"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "appIds": [
    "730"
  ]
}
```

One numeric Steam app ID per line, e.g. 730 (from a store.steampowered.com/app/730/... URL). Accepted formats: 730, https://store.steampowered.com/app/730/CounterStrike\_2/.

```json
{
  "appIds": ["730", "https://store.steampowered.com/app/1091500/Cyberpunk_2077/"],
  "testRun": false,
  "onlyFound": false,
  "columns": ["name", "appId", "priceFinal", "discountPercent", "genres", "metacriticScore"],
  "maxConcurrency": 5,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

`appIds` is a list of numeric Steam app IDs or full store URLs — one per line; a URL is
reduced to its numeric app ID automatically. Turn on `testRun` to process only the first 5
items before running the full list. `onlyFound` hides rows with no result (misses are
always free). `includeKeywords` / `excludeKeywords` filter by keyword, and `maxResults`
stops the run early. `columns` picks which fields appear in each row — all are included by
default.

### Output

| query | found | status | name | appId | type | isFree | priceFinal | priceInitial | priceCurrency | discountPercent | releaseDate | developers | publishers | genres | categories | metacriticScore | recommendationsTotal | platforms | shortDescription | headerImage | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 730 | true | OK | Counter-Strike 2 | 730 | game | true | 0 |  |  | 0 | Aug 21, 2012 | \["Valve"] | \["Valve"] | \["Action","Free To Play"] | \["Multi-player","Cross-Platform Multiplayer","Steam Trading Cards","Steam Workshop","Steam Workshop","In-App Purchases","Adjustable Text Size","Camera Comfort","Color Alternatives","Custom Volume Controls","Playable without Timed Input","Stereo Sound","Surround Sound","Valve Anti-Cheat enabled","Stats","Remote Play on Phone","Remote Play on Tablet","Remote Play on TV","Steam Timeline"] |  | 5235552 | \["windows","linux"] | For over two decades, Counter-Strike has offered an elite competitive experience, one shaped by millions of players from across the globe. And now the next chapter in the CS story is about to begin. This is Counter-Strike 2. | https://shared.akamai.steamstatic.com/store\_item\_assets/steam/apps/730/162664aa5da85f418105350c5d67ca565f6c3713/header.jpg?t=1784564069 | 2026-08-23T21:05:36.231Z |

```json
{
  "query": "730",
  "found": true,
  "status": "OK",
  "name": "Counter-Strike 2",
  "appId": 730,
  "type": "game",
  "isFree": true,
  "priceFinal": 0,
  "priceInitial": null,
  "priceCurrency": null,
  "discountPercent": 0,
  "releaseDate": "21 Aug, 2012",
  "developers": ["Valve"],
  "publishers": ["Valve"],
  "genres": ["Action", "Free to Play"],
  "categories": ["Multi-player", "Steam Achievements"],
  "metacriticScore": 83,
  "recommendationsTotal": 1500000,
  "platforms": ["windows", "mac", "linux"],
  "shortDescription": "For over two decades, Counter-Strike has offered an elite competitive experience.",
  "headerImage": "https://cdn.akamai.steamstatic.com/steam/apps/730/header.jpg",
  "scrapedAt": "2026-08-21T14:03:11.000Z"
}
```

A row is only marked `found: true` — and only then billed — once the app ID resolves to a
real Steam listing (`success: true` in Valve's response). An app ID with no matching Steam
app comes back `status: "NOT_FOUND"`; a non-numeric input that isn't a valid app ID or store
URL comes back `status: "BAD_FORMAT"` — both are `found: false` and never charged.

### Use cases

- Track price and discount changes on a watchlist of games ahead of or during a Steam sale.
- Pull metadata (genres, categories, developers) for a batch of titles to feed a game
  discovery or recommendation tool.
- Monitor Metacritic score and review-count trends for titles you're evaluating or
  tracking competitively.
- Verify platform support (Windows/Mac/Linux) across a list of games before recommending
  or bundling them.
- Enrich an existing catalog or spreadsheet of app IDs with current pricing and release
  data in bulk.

### Pricing

$4 per 1,000 app IDs, plus a $0.005 start fee. Misses (`found:false`) are never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~steam-app-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"appIds":["730"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~steam-app-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"appIds":["730"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~steam-app-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"appIds":["{{app ID}}"]}`, mapping the row's app ID into the `appIds` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Steam Store API — App ID to Price, Genre, Reviews" — the agent will find and run this actor.

### FAQ

**What counts as "not found"?** An app ID with no matching entry in Valve's `appdetails`
response (`success: false` or no data) — this can happen for delisted, region-restricted,
or invalid app IDs.

**Can I paste a full store URL instead of a bare app ID?** Yes — a URL like
`https://store.steampowered.com/app/730/CounterStrike_2/` is reduced to its numeric app ID
(`730`) automatically before the lookup runs.

**Why is `priceInitial` null for a free-to-play game?** Free titles have no
`price_overview` block in Steam's API response — `priceFinal` is reported as `0` and
`priceInitial`/`priceCurrency` stay `null` since there's no list price to report.

**Does `discountPercent` show 0 when a game isn't on sale?** Yes — it defaults to `0`
rather than `null` when there's no active discount, matching what Steam's own API returns.

**What happens with a non-numeric input?** Anything that isn't a numeric app ID (or doesn't
contain one in a URL) comes back as `status: "BAD_FORMAT"` and is never charged.

**Does it require a Steam API key?** No — `appdetails` is a free, public, unauthenticated
endpoint that Valve's own store pages use, so no key or login is needed.

# Actor input Schema

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

One numeric Steam app ID per line, e.g. 730 (from a store.steampowered.com/app/730/... URL). Accepted formats: 730, https://store.steampowered.com/app/730/CounterStrike\_2/. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "appIds": [
    "730"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "name",
    "appId",
    "type",
    "isFree",
    "priceFinal",
    "priceInitial",
    "priceCurrency",
    "discountPercent",
    "releaseDate",
    "developers",
    "publishers",
    "genres",
    "categories",
    "metacriticScore",
    "recommendationsTotal",
    "platforms",
    "shortDescription",
    "headerImage"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "appIds": [
        "730"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/steam-app-lookup").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": ["730"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/steam-app-lookup").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": [
    "730"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/steam-app-lookup --silent --output-dataset

```

## MCP server setup

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

```

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/emU0TeW7OSLdJP0Gx/builds/gl0l1cKfhrxcHdnP9/openapi.json