Discover/Leetify API
live

Leetify APIapi-public-docs.cs-prod.leetify.com

Retrieve CS2 player profiles, match history, and per-match performance metrics from Leetify. Look up by Steam64 ID or Leetify UUID across 5 endpoints.

Endpoint health
verified 4d ago
validate_api_key
get_player_profile
get_player_match_history
get_match_by_game_id
get_match_by_data_source
5/5 passing latest checkself-healing
Endpoints
5
Updated
26d ago

What is the Leetify API?

This API exposes 5 endpoints for querying CS2 player statistics and match data from Leetify. Use get_player_profile to pull a player's aim, positioning, utility, and clutch ratings alongside their Premier, Wingman, and FACEIT ranks, or use get_match_by_game_id and get_match_by_data_source to fetch full per-player stat breakdowns for any recorded match — identified either by Leetify UUID or by the native matchmaking/FACEIT match ID.

Try it
The Leetify API key to validate.
api.parse.bot/scraper/613b2879-eff7-4b2b-842b-cff0fe36b4b6/<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/613b2879-eff7-4b2b-842b-cff0fe36b4b6/validate_api_key?api_key=test-invalid-key' \
  -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 api-public-docs-cs-prod-leetify-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: Leetify CS2 API — player profiles, match history, match details."""
from parse_apis.leetify_public_cs_api import Leetify, ResourceNotFound

client = Leetify()

# Validate an API key — quick connectivity check.
status = client.apikeystatuses.validate(api_key="test-key")
print(f"Key valid: {status.valid} | {status.message}")

# Fetch a player profile by Steam64 ID — typed fields on the result.
player = client.players.get(steam64_id="76561197969209908")
print(f"Player: {player.name} | Matches: {player.total_matches} | Winrate: {player.winrate}")
print(f"Rating — Aim: {player.rating.aim}, Positioning: {player.rating.positioning}")
print(f"Ranks — Premier: {player.ranks.premier}, Faceit: {player.ranks.faceit}")

# Walk the player's match history (limit= caps total items fetched).
for entry in player.match_history(limit=3):
    print(f"Match {entry.id[:8]}… | {entry.map_name} | {entry.data_source} | banned={entry.has_banned_player}")
    for ts in entry.team_scores:
        print(f"  Team {ts.team_number}: {ts.score}")

# Drill into a single match for full per-player stats.
first_match = player.match_history(limit=1).first()
if first_match:
    match = first_match.details()
    print(f"\nMatch detail: {match.map_name} ({match.finished_at})")
    for ps in match.stats:
        print(f"  {ps.name}: K/D {ps.total_kills}/{ps.total_deaths} | Rating: {ps.leetify_rating}")

# Alternative match lookup by data source ID.
alt_match = client.matches.get_by_source(data_source="matchmaking", data_source_id=match.data_source_match_id)
print(f"\nSame match via source: {alt_match.map_name} | {alt_match.id}")

# Typed error handling: catch ResourceNotFound on a bad lookup.
try:
    client.players.get(steam64_id="00000000000000000")
except ResourceNotFound as exc:
    print(f"\nExpected error: {exc}")

print("\nExercised: apikeystatuses.validate / players.get / match_history / details / matches.get_by_source / ResourceNotFound")
All endpoints · 5 totalmissing one? ·

Validates the provided API key against the Leetify API. Returns whether the key is valid and a human-readable message. Useful as a connectivity check before making data calls.

Input
ParamTypeDescription
api_keyrequiredstringThe Leetify API key to validate.
Response
{
  "type": "object",
  "fields": {
    "valid": "boolean indicating whether the API key is valid",
    "message": "string describing the validation result"
  },
  "sample": {
    "data": {
      "valid": false,
      "message": "Invalid or missing API key"
    },
    "status": "success"
  }
}

About the Leetify API

Player Profile Data

The get_player_profile endpoint accepts either a steam64_id (e.g. 76561197969209908) or a Leetify user UUID via the id parameter. It returns a rating object with six scored dimensions — aim, positioning, utility, clutch, opening, ct_leetify, and t_leetify — alongside a ranks object covering leetify, premier, faceit, faceit_elo, wingman, renown, and competitive rank tiers. The stats field contains granular metrics including accuracy, reaction time, and utility usage. The response also surfaces recent_matches, recent_teammates, winrate, total_matches, and the player's current privacy_mode.

Match History and Match Lookup

get_player_match_history returns an array of match objects for a given player, each including map_name, data_source (e.g. matchmaking or faceit), finished_at in ISO 8601 format, team_scores, a has_banned_player flag, and the source-specific data_source_match_id. This last field is the key input for get_match_by_data_source, which retrieves full match data by pairing a data_source string with the corresponding native ID (e.g. a CSGO share code for matchmaking).

Full Match Detail by ID

get_match_by_game_id takes a Leetify game UUID and returns the complete match record including a stats array covering every player in the lobby. This is useful when you already hold a Leetify game ID from a previous API response and want the full lobby breakdown rather than just one player's perspective. Both match-detail endpoints return identical response shapes, so switching between them requires only changing the lookup key.

API Key Validation

The validate_api_key endpoint accepts a Leetify API key string and returns a valid boolean plus a message string. It is useful for checking key status before making downstream calls, particularly in workflows that manage multiple API credentials or onboard users with their own Leetify keys.

Reliability & maintenanceVerified

The Leetify API is a managed, monitored endpoint for api-public-docs.cs-prod.leetify.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when api-public-docs.cs-prod.leetify.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 api-public-docs.cs-prod.leetify.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.

Last verified
4d ago
Latest check
5/5 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
  • Track a CS2 player's aim and positioning ratings over time using repeated calls to get_player_profile
  • Flag matches containing banned players using the has_banned_player field from match history
  • Compare full lobby performance stats after a match using get_match_by_data_source with a matchmaking share code
  • Build a rank tracker by polling the ranks object (premier, FACEIT, wingman) for a list of Steam64 IDs
  • Identify frequent teammates by parsing the recent_teammates array from player profile responses
  • Cross-reference a Leetify game UUID from match history with get_match_by_game_id to fetch all players' detailed stats
  • Validate user-supplied Leetify API keys before storing them using the validate_api_key endpoint
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 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.

Frequently asked questions
Does Leetify have an official public developer API?+
Leetify does not currently publish a broadly documented public API for third-party developers. Their platform is primarily consumer-facing, accessible at leetify.com.
What does `get_player_profile` return beyond basic stats?+
In addition to the stats block (accuracy, reaction time, utility usage), the response includes a rating object with seven scored dimensions (aim, positioning, utility, clutch, opening, ct_leetify, t_leetify), a ranks object covering seven rank types, winrate, total_matches, bans, and privacy_mode. Players with privacy_mode set to non-public may return limited data.
Can I look up a match using a FACEIT match ID instead of a Leetify UUID?+
Yes. The get_match_by_data_source endpoint accepts a data_source string (e.g. faceit or matchmaking) and a data_source_id — the native platform match identifier. This lets you look up a match without first needing a Leetify UUID. The CSGO/CS2 matchmaking share code format (e.g. CSGO-unDnP-jd7LE-tBc3E-PMJve-PjNpP) serves as the data_source_id for matchmaking games.
Does the match history endpoint support pagination or date filtering?+
The current get_player_match_history endpoint does not expose pagination parameters or date range filters — it returns whatever Leetify surfaces for the player by default. You can fork this API on Parse and revise it to add pagination or filtering parameters if your use case requires it.
Is per-round breakdown data (e.g. round-by-round events) available from these endpoints?+
Not currently. The match endpoints return aggregate per-player stats for a match rather than granular round-by-round event sequences. The API covers player-level metrics, team scores, and match metadata. You can fork it on Parse and revise to add a round-detail endpoint if Leetify exposes that data for your key tier.
Page content last updated . Spec covers 5 endpoints from api-public-docs.cs-prod.leetify.com.
Related APIs in SportsSee all →
csstats.org API
Track Counter-Strike 2 player performance with detailed statistics, match history, and leaderboard rankings from csstats.gg. Search players, view their profiles, analyze individual matches, check ban records, and see who they've played with.
csstats.gg API
Access Counter-Strike 2 player statistics, match history, and leaderboard rankings from csstats.gg. Search players by Steam ID or name, retrieve detailed performance metrics and recent match results, explore scoreboard data, view played-with history, and check global ban statistics.
csgostats.gg API
Track and analyze Counter-Strike 2 player performance with detailed statistics including weapon usage, match history, and head-to-head comparisons. Access global leaderboards, view recent matches, and discover which players you've competed against to benchmark your skills.
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.
opendota.com API
Access detailed Dota 2 match statistics, player performance metrics, hero win rates, and professional tournament data to analyze gameplay trends and competitive performance. Search for specific players, explore custom data queries through SQL, and retrieve comprehensive match histories to improve your understanding of the game.
dota2protracker.com API
Track high-level Dota 2 gameplay by accessing real-time hero winrates, professional player match history, and facet performance data. Search the hero database and analyze current meta trends to inform your draft strategy and competitive play.
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.
rocketleague.tracker.network API
Retrieve Rocket League player profiles, historical season statistics, playlist rankings, and recent match session data from Tracker Network. Search for players across platforms and compare performance metrics, rank ratings, and progression across seasons.