Discover/VLR API
live

VLR APIvlr.gg

Access Valorant esports data from VLR.gg: matches, player stats, agent pick rates, team rankings, and event details via 8 structured endpoints.

This API takes change requests — .
Endpoint health
verified 3d ago
get_events
get_matches
get_active_teams
get_match_details
get_rankings
8/8 passing latest checkself-healing
Endpoints
8
Updated
1mo ago

What is the VLR API?

This API exposes 8 endpoints covering the full competitive Valorant data available on VLR.gg, from live event listings to per-map player statistics. The get_match_details endpoint returns individual player performance metrics — kills, deaths, assists, ACS, KAST, ADR, headshot percentage, and first kill/death rates — broken down by map for any completed match. Regional team rankings, agent pick rates, and roster history are also available.

This call costs1 credit / call— charged only on success
Try it

No input parameters required.

api.parse.bot/scraper/17a280c5-4958-46ad-b697-83a15883a046/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/17a280c5-4958-46ad-b697-83a15883a046/get_events' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

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 vlr-gg-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: VLR.gg Valorant Esports SDK — bounded, re-runnable."""
from parse_apis.VLR_gg_Valorant_Esports_API import (
    VLR, MatchStatus, Timespan, PlayerRegion, RankingRegion, ResourceNotFound
)

client = VLR()

# List current events and check agent pick rates for the first one.
event = client.events.list(limit=1).first()
if event:
    print(f"Event: {event.name} (id={event.event_id})")
    for agent in event.agents.list(limit=5):
        print(f"  {agent.agent}: {agent.pick_rate}")

# Browse recent completed matches, then drill into one for map-level stats.
match_summary = client.match_summaries.list(status=MatchStatus.RESULTS, limit=1).first()
if match_summary:
    print(f"Match: {match_summary.team1} vs {match_summary.team2}")
    detail = match_summary.details()
    print(f"  Format: {detail.format}, Date: {detail.date}")
    for stream in detail.streams[:3]:
        print(f"  Stream: {stream.name} ({stream.platform}) — {stream.url}")
    for map_result in detail.maps[:2]:
        print(f"  {map_result.map}: {map_result.score1}-{map_result.score2}")
    if detail.all_maps:
        print(f"  All-maps MVP: {detail.all_maps[0].player} (rating: {detail.all_maps[0].rating})")

# Player stats leaderboard filtered by region and timespan.
for player in client.player_stats.list(
    timespan=Timespan.SIXTY_DAYS, region=PlayerRegion.NA, limit=3
):
    print(f"{player.player} ({player.team}) — rating: {player.rating}, KD: {player.kd}")

# Team rankings and drill into team details with typed error handling.
ranking = client.team_rankings.list(region=RankingRegion.NORTH_AMERICA, limit=1).first()
if ranking:
    try:
        team = ranking.details()
        print(f"{team.team_name} roster: {len(team.roster)} members")
        for member in team.roster[:3]:
            print(f"  {member.player} — {member.role or 'player'}")
    except ResourceNotFound as exc:
        print(f"Team not found: {exc}")

print("exercised: events.list / agents.list / match_summaries.list / details / player_stats.list / team_rankings.list / team details")
All endpoints · 8 totalmissing one? ·

Retrieve current and upcoming Valorant esports events. Returns all events listed on the VLR.gg events page with their IDs, names, status, and detail paths for use with get_agent_stats.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "events": "array of event objects with event_id, detail_path, name, status, and url"
  },
  "sample": {
    "data": {
      "events": [
        {
          "url": "https://www.vlr.gg/event/2765/valorant-masters-london-2026",
          "name": "Valorant Masters London 2026",
          "status": "",
          "event_id": "2765",
          "detail_path": "2765/valorant-masters-london-2026"
        }
      ]
    },
    "status": "success"
  }
}

About the VLR API

Match and Event Data

get_matches returns upcoming fixtures and completed results, each with team names, scores, event context, and a detail_path for drilling into individual matches. Pagination is supported when querying results via the page parameter. get_match_details accepts a match_id path and returns the full series breakdown: team names, series scores, and a maps array where each entry contains per-player stats including rating, acs, kast, adr, hs_percent, and fk/fd counts. get_events lists current and upcoming tournaments with their event_id and detail_path, which feeds directly into get_agent_stats.

Player and Agent Statistics

get_player_stats provides the global leaderboard, filterable by timespan, region, and agent. Each entry includes rounds, rating, kd, kast, adr, kpr, apr, fkpr, fdpr, hs_percent, and cl_p. get_agent_stats takes an event's detail_path and returns every agent's pick_rate for that event — useful for tracking meta shifts across tournaments.

Team Rankings and Rosters

get_rankings returns ranked teams by region, with rank, rating, country, and a detail_path for use with get_team_details. That endpoint exposes the current roster (with player_id and role), a history array of former players, and map_win_rates showing wins, losses, and win rate per map. get_active_teams extends this by fetching teams across all 13 regions when region is set to 'all', returning a total count alongside rank, rating, country, region, and logo URL for each team.

Reliability & maintenanceVerified

The VLR API is a managed, monitored endpoint for vlr.gg — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when vlr.gg 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 vlr.gg 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.

Last verified
3d ago
Latest check
8/8 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a match tracker that polls get_matches for upcoming fixtures and surfaces live scores by team name
  • Aggregate per-map ACS and KAST from get_match_details to compare player performance across a tournament
  • Track agent pick rate trends across events using get_agent_stats with event IDs from get_events
  • Generate regional team rankings dashboards using get_rankings and enrich each entry via get_team_details
  • Monitor roster changes over time by periodically fetching get_team_details and diffing the history array
  • Filter get_player_stats by region and timespan to identify top-performing players in a specific meta window
  • Compile cross-region team data for scouting tools using get_active_teams with region set to 'all'
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 req/min

Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does VLR.gg have an official developer API?+
VLR.gg does not publish an official public developer API. There is no documented REST or GraphQL interface available on their site.
What does get_match_details return beyond the series score?+
It returns a maps array where each element contains the map name, each team's round score on that map, and a player_stats array with individual metrics: kills, deaths, assists, rating, ACS, KAST, ADR, headshot percentage, and first kill and first death counts.
Does get_player_stats support filtering by both region and agent at the same time?+
Yes. The endpoint accepts independent optional parameters — agent (lowercase agent name or 'all'), region (region slug), and timespan — and you can supply any combination of them in a single request.
Is historical match data available beyond the paginated results endpoint?+
get_matches paginates completed results via the page parameter, but there is no dedicated endpoint for querying matches by date range or team. The API covers current events, paginated results, and per-match detail lookups. You can fork it on Parse and revise it to add a date-range or team-filtered history endpoint.
Are individual player profile pages covered, such as career stats or social links?+
Not currently. Player data is exposed through the global leaderboard in get_player_stats and within match-level stats in get_match_details, but there is no endpoint for individual player profile pages with career history or bio data. You can fork it on Parse and revise it to add a player profile endpoint using the player_id values returned in roster and stats responses.
Page content last updated . Spec covers 8 endpoints from vlr.gg.
Related APIs in SportsSee all →
rib.gg API
Access comprehensive Valorant competitive data including match results, player statistics, team information, and tournament details with powerful search and filtering capabilities. Track player performance history, view rankings, discover free agents, and analyze in-depth match rounds and analytics all in one place.
tracker.gg API
Track Valorant player profiles, match histories, competitive rankings, and agent performance statistics from tracker.gg. Search leaderboards, analyze player segments, view daily game data, and access comprehensive reference information covering all Valorant-related data available on the platform.
valoranttracker.com API
Track Valorant player statistics, search for specific players, and view detailed competitive profiles to analyze individual performance. Discover current agent and map meta trends along with global rank distribution data to stay competitive and informed about the game's evolving strategies.
liquipedia.net API
Access comprehensive esports data from Liquipedia, the world's leading esports wiki. Retrieve match schedules, team rosters, player profiles, tournament results, and game-specific statistics across top titles including Valorant, Counter-Strike, League of Legends, and Dota 2.
bo3.gg API
Track and compare professional esports performance across CS2, Valorant, and League of Legends by viewing detailed player statistics like kills, deaths, assists, multikills, and clutches. Discover top-performing players and analyze individual match histories to understand player performance ratings and competitive trends.
leagueofgraphs.com API
Access League of Legends and Teamfight Tactics player statistics, rankings, and match histories. Look up summoner profiles, champion performance data, live game status, and competitive standings across both game modes and all supported regions.
hltv.org API
Access Counter-Strike esports data from HLTV.org including match results, player and team statistics, team rankings, upcoming match schedules, tournament information, and fantasy league data.
lolpros.gg API
Search and discover professional League of Legends players while exploring detailed profiles, ladder rankings, and competitive statistics from the pro scene. Track player performance metrics, find competitors by name, and monitor where top players stand in the rankings.