# ProtonDB Steam Deck & Linux Compatibility Scraper (`maximedupre/protondb`) Actor

Check ProtonDB Linux and Steam Deck compatibility for a list of Steam game IDs. Get current, best-ever, and trending tiers, scores, confidence, community report counts, snapshot times, and source links for each game.

- **URL**: https://apify.com/maximedupre/protondb.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Games, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.45 / 1,000 game compatibilities

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

### 🎮 ProtonDB compatibility for Steam games

For Steam Deck owners, Linux players, and game researchers, this Actor checks a list of Steam game IDs and returns ProtonDB compatibility data you can compare or join with your own game list. Each saved row gives you the current tier, aggregate score, confidence, community report count, best-ever tier, recent trending tier, snapshot time, and direct ProtonDB source link.

- Review a shortlist before playing on a handheld with **[Steam Deck](https://apify.com/maximedupre/protondb/examples/steam-deck)**.
- Check current tiers for several IDs with **[ProtonDB Compatibility](https://apify.com/maximedupre/protondb/examples/protondb-compatibility)**.
- Compare support across your game list with **[Linux Game Compatibility](https://apify.com/maximedupre/protondb/examples/linux-game-compatibility)**.
- Keep the returned fields beside game IDs with **[Steam Game Compatibility](https://apify.com/maximedupre/protondb/examples/steam-game-compatibility)**.
- Review tier history for a shortlist with **[Steam Deck Compatibility](https://apify.com/maximedupre/protondb/examples/steam-deck-compatibility)**.

#### 📊 Steam game compatibility rows

**What you get**

Each saved row gives you the ProtonDB values available for one Steam game ID. Optional values stay absent when ProtonDB has no value, so the dataset does not fill gaps with made-up data. Required fields keep the game ID, read time, and source link.

**Main value**

Use `gameId` to join the compatibility rows to a game list you manage. The direct `sourceUrl` helps you open the ProtonDB source for a row.

#### ▶️ Check a game list with ProtonDB

**Run steps**

1. Add one or more numeric Steam App IDs to `gameIds`, such as `"730"`.
2. Leave `gameIds` out to use the built-in set of popular games.
3. Start the Actor and open the dataset link from the Output section.

**Choose the scope**

Use one or more IDs for a focused run. You can submit a large list in one run. The public schema has no fixed maximum for the list. To limit the lookup work, submit only the IDs you need. If one ID has no usable ProtonDB summary, valid results from other IDs can still be saved.

#### ⚙️ Input

**Input fields**

| Field | Type | What it does |
|---|---|---|
| `gameIds` | array of strings | Numeric Steam App IDs to check, such as `"730"`. Leave this field out to use the built-in set of popular games. |

**Example input**

This successful default-input run used no fields:

```json
{}
```

The empty object uses the built-in popular-game set.

#### 🧾 Output

**Dataset link**

The output is a link to the compatibility dataset. Each saved row matches the shape below. Optional fields are omitted when ProtonDB has no value.

**Field table**

| Field | Type | What it does |
|---|---|---|
| `gameId` | string | The numeric Steam App ID for the game. |
| `currentTier` | string | The current ProtonDB compatibility tier. Omitted when ProtonDB has no tier. |
| `aggregateScore` | number | The aggregate ProtonDB score. Omitted when ProtonDB has no score. |
| `confidenceLevel` | string | The ProtonDB confidence level: `strong`, `good`, `moderate`, `low`, or `inadequate`. Omitted when ProtonDB has no value. |
| `reportCount` | integer | The total number of ProtonDB community reports. Omitted when ProtonDB has no count. |
| `bestEverTier` | string | The best tier ever reported on ProtonDB. Omitted when ProtonDB has no value. |
| `trendingTier` | string | The recent ProtonDB trending tier. Omitted when ProtonDB has no value. |
| `snapshotAt` | string | The time when this ProtonDB result was read. |
| `sourceUrl` | string | A direct ProtonDB source reference for this result. |

**Example row**

This genuine row came from the current beta build's successful default-input run. It is shown in full.

```json
{
  "gameId": "730",
  "snapshotAt": "2026-08-13T17:48:34.801Z",
  "sourceUrl": "https://www.protondb.com/api/v1/reports/summaries/730.json",
  "currentTier": "gold",
  "aggregateScore": 0.71,
  "confidenceLevel": "strong",
  "reportCount": 2009,
  "bestEverTier": "platinum",
  "trendingTier": "platinum"
}
```

#### 💳 Pricing

**Event price**

You are billed $0.00045 for each game compatibility check saved to your dataset.

#### 🔌 Integrations

**Video guide**

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

**Use the dataset**

Open the dataset link in the Output section from your own code or workflow. Join each row to your game list with `gameId`, and follow `sourceUrl` when you need the ProtonDB source.

#### ❓ FAQ

##### Do I need a ProtonDB account or API key?

No. Enter Steam App IDs only. The Actor reads ProtonDB's public API and does not ask for source credentials.

##### Can I submit game names or Steam store URLs?

No. The input accepts numeric Steam App IDs as strings, such as `730`. It does not search Steam by title or crawl the Steam catalog.

##### What happens if one ID has no usable summary?

The Actor keeps valid results for the other IDs. It leaves unavailable ProtonDB values unavailable instead of making them up.

##### Why is a field missing from a row?

Fields such as `currentTier`, `aggregateScore`, and `reportCount` are omitted when ProtonDB has no value. Required `gameId`, `snapshotAt`, and `sourceUrl` remain in a saved row.

##### What does snapshotAt mean?

`snapshotAt` is the time when the Actor read that ProtonDB result. `sourceUrl` points to the direct ProtonDB source reference.

##### Does this install or test games?

No. It reads compatibility data. It does not install, launch, benchmark, or test games on hardware.

##### Is this a full Steam catalog?

No. It returns ProtonDB compatibility fields for the IDs you submit. It does not add genre, price, release date, or other catalog fields.

##### How is pricing calculated?

You are billed once for each returned game compatibility check at $0.00045.

### 📝 Changelog

**0.0: Initial release**

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~protondb/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [ProtonDB Steam Deck & Linux Compatibility Scraper](https://apify.com/jungle_synthesizer/protondb-steamdeck-linux-compatibility-scraper): Compare ProtonDB compatibility data for the same Steam game IDs.
- [Steam Game Scraper - Prices, Reviews & Player Stats](https://apify.com/viralanalyzer/steam-game-intelligence): Add prices, reviews, and player counts to your game research.
- [Steam Store Scraper: Games, Charts & Reviews](https://apify.com/scrapingmonkey/steam-store-scraper): Add Steam store details, charts, and reviews beside compatibility rows.
- [Steam Game Price Tracker — Official API, Regional Pricing](https://apify.com/bovi/steam-scraper): Compare regional prices and discounts for the same games.
- [Steam Games Scraper - Prices, Genres & Metadata](https://apify.com/benthepythondev/steam-games-scraper): Add genres, developers, release dates, and store URLs to your game list.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `gameIds` (type: `array`):

Add one or more numeric Steam App IDs, such as 730. The Actor checks each ID and keeps valid results if another ID has no usable ProtonDB summary.

## Actor input object example

```json
{
  "gameIds": [
    "730",
    "1245620",
    "413150"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open the dataset rows for the checked Steam games.

# 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 = {
    "gameIds": [
        "730",
        "1245620",
        "413150"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/protondb").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 = { "gameIds": [
        "730",
        "1245620",
        "413150",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/protondb").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 '{
  "gameIds": [
    "730",
    "1245620",
    "413150"
  ]
}' |
apify call maximedupre/protondb --silent --output-dataset

```

## MCP server setup

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

```

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/ezRszZGcaIxafs8vR/builds/NdBsdTu1vCmuBKbME/openapi.json