Riot Games VALORANT API

Overview

The Riot Games VALORANT API offers a structured interface for developers to retrieve extensive data related to the tactical first-person shooter, VALORANT. This API serves as the backbone for numerous community-driven platforms, professional esports analysis tools, and personalized player experience applications. It provides access to a variety of endpoints covering match data, player statistics, leaderboards, and general game information, enabling the creation of dynamic and interactive tools.

Developers primarily utilize the VALORANT API to build applications such as:

• Player Stat Trackers: Platforms that display individual player performance metrics, match history, and rank progression, similar to Tracker Network's VALORANT profile pages.
• Custom Game Companion Apps: Tools that augment the in-game experience by offering real-time insights or post-match analysis.
• Esports Data Analysis: Systems for professional teams, analysts, and broadcasters to dissect competitive matches, player performance, and strategic trends within the VALORANT esports ecosystem, as seen in platforms like TheSpike.gg.
• Community Tools: Websites or bots that facilitate community engagement, such as leaderboards, tournament organizers, or content generation based on game data.

Access to the API is managed through the Riot Games Developer Portal, which provides comprehensive documentation, API key management, and clear guidelines for usage. The API is generally straightforward for personal projects, allowing developers to experiment and build without immediate commercial constraints, provided they adhere to established rate limits. For commercial applications, explicit approval from Riot Games is required, which may involve additional terms and conditions.

The API's design reflects a commitment to supporting the VALORANT ecosystem, offering robust data access while maintaining control over data integrity and preventing misuse. It empowers a broad range of developers, from independent enthusiasts to established companies, to innovate within the VALORANT community.

Key features

• Match History Data: Access detailed information for past matches, including player performance, agent selections, scores, and specific in-game events. This allows for in-depth post-match analysis and player progress tracking.
• Player Statistics: Retrieve individual player data such as win rates, KDA (kills/deaths/assists), average combat score, and rank information across various game modes.
• Leaderboards: Programmatically fetch regional and global leaderboards, providing insights into top-ranked players and competitive standings.
• Game Content & Assets: Access data related to agents, maps, weapon skins, and other in-game content, which can be used to enrich companion applications with visual and informational elements.
• Regional Endpoints: Support for multiple geographical regions, allowing developers to target specific player bases and competitive scenes.
• Developer Portal & Documentation: A centralized portal offering API key management, clear documentation for all endpoints, usage policies, and community support resources.
• Rate Limit Management: Built-in mechanisms to manage API requests, ensuring fair usage and preventing server overload, with different tiers for personal and commercial projects.

Pricing

As of May 5, 2026, the Riot Games VALORANT API primarily operates under a free-tier model for non-commercial use, with specific conditions for commercial applications.

Further details on rate limits and commercial application processes are available on the Riot Games Developer Portal.

Common integrations

• Web Applications: Building interactive websites for player stats, leaderboards, or esports news, often leveraging frontend JavaScript frameworks.
• Discord Bots: Developing bots to retrieve real-time player stats, match results, or game updates directly within Discord servers.
• Mobile Applications: Creating iOS or Android apps for on-the-go VALORANT statistics and player tracking.
• Esports Analytics Platforms: Integrating into larger data platforms for in-depth analysis of competitive matches and player performance for professional organizations.
• Streaming Overlays: Developing custom overlays for live streamers to display dynamic VALORANT game data.

Alternatives

• Tracker Network: Offers aggregated statistics and player profiles for various games, including VALORANT, built on top of game APIs.
• Blitz.gg: Provides in-game overlays and post-match analysis for multiple titles, relying on game data for real-time insights.
• Mobalytics: Focuses on coaching and analytics tools for competitive games, utilizing API data to offer performance feedback.

Getting started

To begin using the Riot Games VALORANT API, developers must first register for an API key through the Riot Games Developer Portal. Once an API key is obtained, requests can be made to the various endpoints. Below is a basic example using Python's requests library to fetch a player's match history.

import requests
import os

# Replace with your actual API key and player PUUID
API_KEY = os.environ.get("RIOT_API_KEY") # It's best practice to use environment variables
PLAYER_PUUID = "your_player_puuid_here" # This is a unique player identifier
REGION = "na" # e.g., na, eu, kr, ap, latam, br

# Base URL for VALORANT Match-V1 API
# Note: API routes often combine region and specific endpoint subdomains
# Check the official documentation for correct regional routing for each API.
# For VALORANT, match data is typically accessed via 'americas', 'europe', 'asia'.
# For player data, it's typically direct regional shards like 'na1', 'euw1'.
# Let's use the 'americas' regional routing for match history for this example.
# You would need to map your game region (e.g., 'na') to the correct 'regional routing value'.
# For simplicity, we'll use a placeholder URL and note the actual process.

# For VALORANT match history, you map game regions to the following 'regional routing values':
# Americas: br, latam, na
# Europe: eu, tr
# Asia: ap, kr
# See: https://developer.riotgames.com/docs/valorant#general-api-usage_regional-routing

REGIONAL_ROUTING = {
    "na": "americas",
    "eu": "europe",
    "kr": "asia",
    "ap": "asia",
    "br": "americas",
    "latam": "americas"
}

routing_value = REGIONAL_ROUTING.get(REGION.lower())

if not routing_value:
    print(f"Error: Invalid region '{REGION}'. Please use one of {list(REGIONAL_ROUTING.keys())}")
    exit()

MATCH_HISTORY_URL = f"https://{routing_value}.api.riotgames.com/val/match/v1/matchlists/by-puuid/{PLAYER_PUUID}"

headers = {
    "X-Riot-Token": API_KEY
}

try:
    response = requests.get(MATCH_HISTORY_URL, headers=headers)
    response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)

    match_data = response.json()

    print(f"Successfully fetched match history for PUUID: {PLAYER_PUUID}")
    if match_data and 'history' in match_data:
        for match in match_data['history'][:5]: # Print details for the first 5 matches
            print(f"  Match ID: {match['matchId']}, Game Start: {match['gameStartMillis']}")
    else:
        print("No match history found or unexpected response format.")

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err} - {response.text}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An unexpected error occurred: {req_err}")
except Exception as e:
    print(f"An error occurred: {e}")

Before running this code, ensure you have obtained your API key from the Riot Games Developer Portal and set it as an environment variable (RIOT_API_KEY). You will also need to replace your_player_puuid_here with a valid player PUUID (Player Universal Unique Identifier), which can often be found through other API calls or existing community tools. The example demonstrates fetching a list of match IDs, which can then be used to query individual match details via the /val/match/v1/matches/{matchId} endpoint for more granular data.