ProtonDB APIprotondb.com ↗
Access ProtonDB game compatibility tiers, user reports, Steam Deck verification status, and global stats for any Steam App ID via a structured API.
What is the ProtonDB API?
This API exposes 8 endpoints covering ProtonDB's full dataset of Linux and Steam Deck game compatibility data. Use get_game_summary to retrieve a game's tier rating (platinum through borked), confidence level, and total report count by Steam App ID, or call get_game_reports to pull individual user-submitted reports with hardware specs and Proton version details. The API also surfaces global statistics, dashboard breakdowns by catalog size, Steam Deck verification criteria, and a searchable game index.
curl -X GET 'https://api.parse.bot/scraper/566b9bab-74d5-4cf8-9980-34c236c0e3b3/search_games?query=Portal+2' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace protondb-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""ProtonDB SDK — check Linux game compatibility, reports, and Steam Deck status."""
from parse_apis.protondb_api import ProtonDB, ExploreSort, Device, GameNotFound
client = ProtonDB()
# Search for a game by title, take the first result.
game = client.games.search(query="Portal 2", limit=3).first()
print(f"Found: {game.name} (app_id={game.app_id})")
# Get the compatibility summary for that game.
summary = game.summary()
print(f"Tier: {summary.tier}, Score: {summary.score}, Confidence: {summary.confidence}")
# Check Steam Deck verification status.
deck = game.deck_status()
print(f"Deck verified category: {deck.results.resolved_category}")
for item in deck.results.resolved_items:
print(f" Test: {item.loc_token} (type={item.display_type})")
# List user reports filtered to Steam Deck device.
for report in game.reports.list(device=Device.STEAM_DECK, limit=3):
print(f"Report {report.id}: verdict={report.responses.get('verdict', 'n/a')}, hw={report.device.hardware_type}")
# Browse the explore page sorted by worst compatibility.
for eg in client.exploregames.list(sort=ExploreSort.MOST_BORKED, limit=3):
print(f"Borked: {eg.title} ({eg.app_id}) status={eg.whitelist_status}")
# Handle a not-found game gracefully.
try:
bad_game = client.game(app_id="9999999")
bad_game.summary()
except GameNotFound as exc:
print(f"Game not found: {exc.app_id}")
# Global stats.
stats = client.statses.get()
print(f"ProtonDB has {stats.unique_games} games with {stats.reports} total reports")
print("Exercised: games.search / summary / deck_status / reports.list / exploregames.list / statses.get")
Full-text search over the ProtonDB game index by title. Returns matching games with their Steam App IDs. Each hit carries the game name and its Steam App ID (objectID). Limited to 20 results per call.
| Param | Type | Description |
|---|---|---|
| queryrequired | string | Search keyword or game title to find matching games. |
{
"type": "object",
"fields": {
"hits": "array of game objects with name and objectID (Steam App ID)",
"query": "string, the search query echoed back",
"nbHits": "integer, total number of matching results"
},
"sample": {
"data": {
"hits": [
{
"name": "Portal 2",
"objectID": "620"
}
],
"query": "Portal 2",
"nbHits": 166
},
"status": "success"
}
}About the ProtonDB API
Game Compatibility Endpoints
get_game_summary takes a Steam app_id and returns the core compatibility fields: tier (one of platinum, gold, silver, bronze, or borked), a numeric score between 0 and 1, confidence (strong, good, or inadequate), trendingTier, and bestReportedTier. This gives a quick read on how reliably a title runs under Proton. get_game_reports returns paginated individual reports for the same app_id, each containing contributor details, system specs, Proton version, timestamp, and user notes. The optional device parameter lets you filter to pc, steam-deck, or chrome-os reports specifically.
Search and Explore
search_games queries the game index by title string and returns an array of hits, each with a game name and objectID (the Steam App ID you need for other endpoints), plus nbHits indicating total matches. explore_games_list offers a paginated catalog view with sort options including popular, releaseDate, wilsonRating, playerCount, userScore, and mostBorked. Each result includes appId, title, and whitelistStatus.
Steam Deck Verification and Steam Store Details
get_deck_verified_details returns Valve's official Steam Deck compatibility assessment for a given app_id. The resolved_category field uses numeric codes: 3 for Verified, 2 for Playable, 1 for Unsupported, and 0 for Unknown. The resolved_items array breaks down individual test criteria results. get_steam_app_details returns full Steam store metadata for the same app — description, pricing, system requirements, and media — keyed by app_id.
Global Statistics
get_stats_summary returns site-wide counts: total reports, uniqueGames with at least one submission, and a timestamp of the last data update. get_dashboard_stats goes deeper, providing compatibility breakdowns across topTen, topHundred, topThousand, and fullSteamCatalog game sets, each segmented by ProtonDB medal tiers, click-play categories, and Steam Deck verification ratings.
The ProtonDB API is a managed, monitored endpoint for protondb.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when protondb.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official protondb.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a Linux gaming compatibility checker that looks up any Steam App ID and displays its ProtonDB tier and confidence level.
- Filter Steam libraries by Proton compatibility tier to surface only gold or platinum-rated titles for a given user's game list.
- Compare official Steam Deck Verified status (from
get_deck_verified_details) against community ProtonDB tiers to flag disagreements. - Aggregate
get_dashboard_statsbreakdowns over time to track how the proportion of Verified Steam Deck titles in the full catalog changes. - Surface recent user reports filtered to
steam-deckdevice type to show hardware-specific notes and Proton versions for a title. - Power a game discovery page sorted by
wilsonRatingoruserScorefromexplore_games_listto surface well-reported Linux-compatible titles. - Cross-reference
get_steam_app_detailspricing and system requirements with ProtonDB compatibility tier to build a Linux-focused game buying guide.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does ProtonDB have an official public developer API?+
What does the `tier` field in `get_game_summary` actually represent?+
tier field reflects the aggregate community compatibility rating derived from user reports. Values run from platinum (works perfectly out of the box) down through gold, silver, bronze, and borked (does not run). The response also includes trendingTier for the current directional trend and bestReportedTier for the highest tier ever reported, which can differ from the current aggregate.Can I retrieve historical compatibility data or track how a game's tier has changed over time?+
How does report pagination work in `get_game_reports`?+
page (current page), perPage (results per page), and total (total reports for the game). There is no explicit page input parameter exposed in the current endpoint definition, so the API returns the default first page of results. For games with high report counts, the total field tells you how many reports exist in full.