OpenDota APIopendota.com ↗
Access Dota 2 match data, player stats, hero win rates, and pro match results via the OpenDota API. Supports SQL queries, player search, and more.
What is the OpenDota API?
This API exposes 8 endpoints covering Dota 2 match data, player profiles, hero statistics, and professional match results from OpenDota. The get_match endpoint returns over 9 fields per match including players, duration, radiant_win, and game_mode. The get_explorer endpoint lets you run raw SQL SELECT queries against OpenDota's match database, giving you access to custom aggregations across matches, heroes, leagues, and teams.
curl -X GET 'https://api.parse.bot/scraper/49173147-70df-4c2d-bade-d462c1e1cbbb/get_match?match_id=8846649222' \ -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 opendota-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.
"""Walkthrough: OpenDota SDK — Dota 2 match data, players, heroes, and pro scene."""
from parse_apis.OpenDota_API import OpenDota, NotFoundError
client = OpenDota()
# Search players by name and inspect results
for player in client.players.search(query="dendi", limit=5):
print(player.personaname, player.account_id)
# Get a specific player profile and check their win/loss record
player = client.players.get(account_id=87278757)
print(player.personaname, player.rank_tier, player.leaderboard_rank)
wl = player.win_loss(date=30)
print(wl.win, wl.lose)
# List hero stats — every hero with pro pick/win/ban rates
for hero in client.heros.list(limit=5):
print(hero.localized_name, hero.primary_attr, hero.pro_pick, hero.pro_win)
# Browse recent pro match fixtures, then drill into full match details
fixture = client.fixtures.list(limit=1).first()
if fixture:
print(fixture.radiant_name, fixture.dire_name, fixture.radiant_win)
match = fixture.details.get()
print(match.match_id, match.duration, match.radiant_score, match.dire_score)
for p in match.players[:2]:
print(p.personaname, p.hero_id, p.kills, p.deaths, p.assists)
# Execute a custom SQL query against the OpenDota database
result = client.query_results.execute(sql="SELECT match_id FROM matches LIMIT 1")
print(result.command, result.rowCount)
# Typed error handling
try:
client.matches.get(match_id=9999999999)
except NotFoundError as exc:
print(f"match not found: {exc}")
print("exercised: players.search / players.get / win_loss / heros.list / fixtures.list / details.get / query_results.execute / matches.get")
Retrieve comprehensive match data including duration, scores, players, and advanced statistics for a specific match. Each player entry contains hero, items, kills/deaths/assists, gold/xp rates, benchmarks, and more.
| Param | Type | Description |
|---|---|---|
| match_idrequired | integer | Numeric match ID to retrieve data for. |
{
"type": "object",
"fields": {
"players": "array of player objects with detailed stats",
"duration": "integer match duration in seconds",
"match_id": "integer match identifier",
"game_mode": "integer game mode identifier",
"dire_score": "integer total Dire kills",
"lobby_type": "integer lobby type identifier",
"start_time": "integer Unix timestamp of match start",
"radiant_win": "boolean indicating if Radiant team won",
"radiant_score": "integer total Radiant kills"
},
"sample": {
"data": {
"players": [
{
"kills": 5,
"deaths": 8,
"assists": 11,
"hero_id": 9,
"account_id": 118774641,
"xp_per_min": 1618,
"gold_per_min": 866
}
],
"duration": 1702,
"match_id": 7900000001,
"game_mode": 23,
"dire_score": 34,
"lobby_type": 0,
"start_time": 1723833571,
"radiant_win": false,
"radiant_score": 38
},
"status": "success"
}
}About the OpenDota API
Match and Player Data
The get_match endpoint accepts a match_id and returns structured match data: duration in seconds, start_time as a Unix timestamp, game_mode and lobby_type as integer identifiers, radiant_win as a boolean, team kill totals (radiant_score, dire_score), and a players array with per-player statistics. The get_player endpoint takes a Steam account_id and returns a profile object with fields like personaname, avatarfull, profileurl, and loccountrycode, alongside rank_tier and leaderboard_rank.
Filtering Win/Loss Records and Searching Players
get_player_win_loss returns simple win and lose counts for any account_id, with optional filters for hero_id, game_mode, lobby_type, region, patch, and date (days back from today). search_players accepts a query string matched against player display names and returns account_id, personaname, avatarfull, and last_match_time for each match.
Hero Stats and Professional Scene
get_hero_stats returns an array of all heroes with no required inputs. Each hero object includes id, localized_name, primary_attr, attack_type, roles, and pro scene stats: pro_pick, pro_win, and pro_ban. get_pro_players lists professional players with name, team_name, team_tag, country_code, and linked Steam identifiers. get_pro_matches returns recent professional matches ordered by match_id descending, including radiant_name, dire_name, league_name, start_time, duration, and radiant_win. Pagination is handled via the less_than_match_id parameter.
Custom SQL Queries via Explorer
The get_explorer endpoint accepts any SQL SELECT statement and returns rows (an array of result objects), rowCount, and the command string. Supported tables include matches, players, heroes, leagues, and teams. This allows aggregations, joins, and filters that the other endpoints do not expose directly.
The OpenDota API is a managed, monitored endpoint for opendota.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when opendota.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 opendota.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?+
- Track a player's win rate on a specific hero by filtering
get_player_win_losswithhero_id - Pull recent professional match results including team names and leagues using
get_pro_matches - Build a hero tier list using
pro_pick,pro_win, andpro_banfields fromget_hero_stats - Look up a player's current rank tier and leaderboard position from
get_player - Find all Steam accounts matching a display name using
search_playersbefore fetching full profile data - Run custom SQL aggregations over the OpenDota match database using
get_explorerto compute patch-level meta statistics - Retrieve full match timelines including per-player stats for a given
match_idusingget_match
| 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 OpenDota have an official developer API?+
What filters does `get_player_win_loss` support?+
hero_id, game_mode, lobby_type, region, patch, and date (number of days back from today) as optional filters, all combined with the required account_id. Each filter narrows the win/loss count independently.How does pagination work for `get_pro_matches`?+
match_id descending. To fetch the next page, pass the lowest match_id from the current response as the less_than_match_id parameter on the next request.Does the API return match history for a specific player — all their recent matches, not just win/loss counts?+
get_player_win_loss and full detail for a known match_id via get_match, but does not expose a match history list per player. You can fork this API on Parse and revise it to add a player matches endpoint.Does `get_hero_stats` include rank-bracket breakdowns, such as win rates at Herald vs. Immortal?+
pro_pick, pro_win, pro_ban), primary_attr, attack_type, and roles. Rank-bracket win rate breakdowns are not exposed. You can fork this API on Parse and revise it to add fields from OpenDota's full hero stats response if that data is needed.