Discover/csstats API
live

csstats APIcsstats.gg

Access CS2 player stats, match history, scoreboards, leaderboards, and ban data from csstats.gg via 7 structured API endpoints.

Endpoint health
verified 18h ago
get_match_scoreboard
get_ban_stats
get_leaderboard
get_player_stats
get_player_matches
6/6 passing latest checkself-healing
Endpoints
7
Updated
9d ago

What is the csstats API?

The csstats.gg API exposes 7 endpoints covering Counter-Strike 2 player statistics, match history, and leaderboard data. Starting with search_player, you can resolve a Steam ID, display name, or profile URL into a csstats.gg profile, then pull aggregated career stats like K/D, HLTV Rating, ADR, and HS% from get_player_stats. Match-level data includes full per-player scoreboards, and a dedicated endpoint surfaces global VAC ban counts for the past 30 days.

Try it
Steam ID (17-digit numeric), player name, or Steam profile URL
api.parse.bot/scraper/758b30c6-74c7-46ea-a4fb-2efd60740f7c/<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/758b30c6-74c7-46ea-a4fb-2efd60740f7c/search_player?query=s1mple' \
  -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 csstats-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: CSStats SDK — Counter-Strike 2 player stats, matches, leaderboards."""
from parse_apis.CSStats_gg_API import CSStats, LeaderboardMode, PlayerNotFound

cs = CSStats()

# Search for a player by name
for result in cs.players.search(query="s1mple", limit=3):
    print(result.name, result.steam_id, result.profile_url)

# Drill into the first search result's full stats
first = cs.players.search(query="s1mple", limit=1).first()
if first:
    player = first.details()
    print(player.name, player.steam_id)
    for stat_name, stat_value in player.overview.items():
        print(f"  {stat_name}: {stat_value}")

# List recent matches for a player
full_player = cs.players.get(steam_id="76561197978186923")
for match in full_player.matches.list(limit=3):
    print(match.date, match.map, match.score, match.k, match.d, match.rating)

# Get the full scoreboard for a specific match
match = full_player.matches.list(limit=1).first()
if match:
    board = match.scoreboard()
    for team in board.teams:
        for mp in team:
            print(f"  {mp.name} K:{mp.k} D:{mp.d} A:{mp.a} Rating:{mp.rating}")

# Browse the premier leaderboard
for entry in cs.leaderboard(mode=LeaderboardMode.PREMIER).top(limit=5):
    print(entry.rank, entry.name, entry.elo)

# Typed error handling for a non-existent player
try:
    cs.players.get(steam_id="00000000000000000")
except PlayerNotFound as exc:
    print(f"Player not found: {exc.steam_id}")

# Fetch global ban statistics
report = cs.ban_reports.fetch()
print(f"Bans in last 30 days: {report.total_bans_30d}")

print("exercised: players.search / players.get / details / matches.list / scoreboard / leaderboard.top / ban_reports.fetch")
All endpoints · 7 totalmissing one? ·

Search for a player by Steam ID, name, or profile URL. When a 17-digit Steam ID is provided, returns the resolved profile URL directly. Name-based queries resolve via the site's search form and may return multiple matching players.

Input
ParamTypeDescription
queryrequiredstringSteam ID (17-digit numeric), player name, or Steam profile URL
Response
{
  "type": "object",
  "fields": {
    "players": "array of player objects with name, steam_id, profile_url (present when multiple results found)",
    "steam_id": "string - resolved 64-bit Steam ID (present for single-result lookups)",
    "profile_url": "string - full URL to the player's csstats.gg profile (present for single-result lookups)"
  },
  "sample": {
    "data": {
      "players": [
        {
          "name": "s1mple",
          "steam_id": "76561197978186923",
          "profile_url": "https://csstats.gg/player/76561197978186923"
        }
      ]
    },
    "status": "success"
  }
}

About the csstats API

Player Lookup and Career Stats

Use search_player with a 17-digit Steam ID, a player name, or a full Steam profile URL. A Steam ID input resolves directly to a profile_url and confirmed steam_id. Name queries may return an array of matching player objects, each with name, steam_id, and profile_url. Once you have a Steam ID, get_player_stats returns the player's display name and an overview object containing labeled stat pairs — K/D, HLTV Rating, Win Rate, HS%, ADR, and other aggregated career metrics.

Match History and Scoreboards

get_player_matches accepts a steam_id and returns a matches array sorted most-recent first. Each entry includes match_id, date, map, score, and individual performance fields: k (kills), d (deaths), a (assists), and rating. To drill into a specific game, pass the match_id to get_match_scoreboard, which returns two teams of up to five players each, with per-player name, steam_id, k, d, a, and rating.

Leaderboards and Social Graph

get_leaderboard accepts an optional mode parameter (premier or wingman) and returns a ranked list of top players with rank, name, steam_id, and elo. get_player_played_with returns players who have shared matches with a given Steam ID, with an offset parameter for pagination through results.

Ban Statistics

get_ban_stats takes no inputs and returns total_bans_30d — a comma-formatted string of the total VAC and game bans detected across all tracked players in the past 30 days. This gives a platform-wide signal of ban activity without tying to a specific player.

Reliability & maintenanceVerified

The csstats API is a managed, monitored endpoint for csstats.gg — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when csstats.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 csstats.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
18h ago
Latest check
6/6 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 K/D, ADR, and HLTV Rating over time using get_player_stats
  • Build a match review tool that pulls full scoreboard data via get_match_scoreboard using match IDs from get_player_matches
  • Display current Premier and Wingman leaderboard rankings in a third-party CS2 companion app using get_leaderboard
  • Identify frequent teammates or opponents for a player using get_player_played_with
  • Monitor platform-wide VAC and game ban trends with the 30-day aggregate from get_ban_stats
  • Resolve arbitrary Steam names or profile URLs to Steam IDs for downstream stats lookups via search_player
  • Compare squad members' win rates and HS% before a match by batch-querying get_player_stats per Steam ID
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 csstats.gg have an official developer API?+
csstats.gg does not publish an official public developer API or documented REST endpoints for third-party use.
What does get_player_stats actually return, and is it career-wide or per-season?+
get_player_stats returns an overview object containing aggregated stats labeled as they appear on the player profile — including K/D, HLTV Rating, Win Rate, HS%, and ADR. These reflect career aggregates as tracked by csstats.gg rather than a filterable per-season or per-mode breakdown. The API does not currently expose per-season splits. You can fork it on Parse and revise to add a season-scoped endpoint if that granularity is needed.
How do name-based searches behave compared to Steam ID lookups in search_player?+
When you supply a 17-digit Steam ID, the endpoint resolves directly to a single steam_id and profile_url. Name-based queries go through the site's search and may return an array of player objects when multiple accounts share a similar name. For deterministic lookups, Steam IDs are more reliable than display names.
Does the API expose map-specific or weapon-specific stats?+
Not currently. The API covers overall career stats via get_player_stats and per-match K/D/A/rating via get_player_matches and get_match_scoreboard, but there are no endpoints for per-map aggregates or weapon breakdowns. You can fork it on Parse and revise to add those endpoints.
Is there pagination support for match history or played-with results?+
get_player_played_with accepts an offset integer for pagination. get_player_matches does not expose an offset or page parameter in the current spec — it returns the most recent matches available on the player's profile. If deeper match history pagination is needed, you can fork it on Parse and revise to add offset support to that endpoint.
Page content last updated . Spec covers 7 endpoints from csstats.gg.
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.
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.
api-public-docs.cs-prod.leetify.com API
Access CS2 player statistics, match history, and individual game performance data from Leetify's competitive database. Look up player profiles by Steam64 ID or Leetify user ID and retrieve comprehensive match details including per-round metrics and performance breakdowns.
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.
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.
steamcharts.com API
Track player counts and trending games on Steam, search for specific titles, and view historical statistics for individual games. Monitor which games are gaining popularity and get detailed player data to stay informed about the gaming landscape.
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.
csgo.steamanalyst.com API
Track CS2 skin prices in real-time, search for specific skins, and analyze market trends with historical pricing data and top gainers. Compare marketplace listings across different weapons and collections to make informed trading decisions.