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.
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.
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'
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")
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.
| Param | Type | Description |
|---|---|---|
| api_keyrequired | string | The Leetify API key to validate. |
{
"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.
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.
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 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_playerfield from match history - Compare full lobby performance stats after a match using
get_match_by_data_sourcewith a matchmaking share code - Build a rank tracker by polling the
ranksobject (premier, FACEIT, wingman) for a list of Steam64 IDs - Identify frequent teammates by parsing the
recent_teammatesarray from player profile responses - Cross-reference a Leetify game UUID from match history with
get_match_by_game_idto fetch all players' detailed stats - Validate user-supplied Leetify API keys before storing them using the
validate_api_keyendpoint
| 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 Leetify have an official public developer API?+
What does `get_player_profile` return beyond basic stats?+
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?+
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?+
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.