Hugging Face's logo

Datasets:
KEDevO
/
CounterQuant-CS2-Silver

Tasks:
Tabular Classification
Tabular Regression
Other
Languages:
English
Size:
100K<n<1M
Tags:
cs2
counter-strike
esports
sports-analytics
competitive-gaming
match-results
License:
Dataset card Files
xet
 Community

The dataset is currently empty. Upload or create new data files. Then, you will be able to explore them in the Dataset Viewer.

CounterQuant CS2 Silver

Normalized, canonical professional CS2 match data — every match result, map score, and player stat line from 2012 to present.

⭐ If you use this dataset in research, a product, or any publication, please cite the author (see Citation below).

Sourced from HLTV.org and Liquipedia, normalized into clean relational tables, and exported as Parquet. This is the structured "source of truth" layer of the CounterQuant data stack — match records, per-map scores, player performance statistics, event metadata, roster history, and map veto sequences.

Curated and maintained by Eimantas Kulbe (KEDevO) as part of the CounterQuant esports intelligence platform.

The CounterQuant Data Stack

Silver sits in the middle of a four-tier architecture:

Tier Dataset Contents Status
Raw demos CounterQuant CS2 Demos Raw .dem files, parse them yourself Live
Bronze CounterQuant CS2 Bronze Tick-level events: kills, damages, flashes, utility Live, growing
Silver ← this dataset — Match results, map scores, player stats, rosters, events Staging for export
Gold Lite CounterQuant CS2 GoldLite ML-ready features: Elo, form, head-to-head, event context Staging for export

Silver does not require demo parsing — it covers all professional matches regardless of demo availability.

Dataset at a Glance

Metric Value
Total matches in DB 119,445
2024 matches (first public release) 9,248
Match maps in DB 190,446
Player-map stat rows 379,459
Events tracked 8,639
Teams tracked 11,223
Professional players tracked 1,272
Roster records 2,695
Veto sequences 108,777
Year range 2012 – present
Tiers T1, T2, T3 professional
Sources HLTV.org, Liquipedia
Format Parquet (Snappy compression)
License CC BY 4.0

Current State & Release Schedule

Silver is not yet published to HuggingFace as Parquet files. The underlying data exists in CounterQuant's PostgreSQL database. Export and upload is in progress, with 2024 as the first public batch.

Release Year Coverage Target Date Notes
v1 — 2024 Jan 2024 – Dec 2024 Q3 2026 T1/T2/T3 · ~9,248 matches · first public release
Backfill — 2012–2023 2012 – 2023 Q4 2026 Historical backfill once 2024 is complete
v2 — 2025 Jan 2025 – Dec 2025 2027 2-year delay policy — released when 2025 is complete
2026 and beyond 2026+ 2028+ 2-year delay · minimum 2-year embargo

Why a 2-year delay for recent data? The Silver dataset is the foundation for the CounterQuant prediction pipeline. Recent data is used internally for model training and edge detection. It is released to the public on a 2-year rolling window to protect proprietary signal while still giving the research community access to a large, high-quality historical dataset.

What's in Silver

Silver contains eight normalized tables exported as per-year Parquet files:

Table Description Current DB rows
matches One row per match series 119,445
maps One row per map played within a match 190,446
player_stats Per-player per-map stats (kills, ADR, KAST, rating) 379,459
events Tournament/event metadata 8,639
players Professional player directory 1,272
teams Team directory 11,223
rosters Player–team assignment history 2,695
vetoes Map veto sequences 108,777

What Silver does NOT contain (see other tiers):

  • Tick-level kill/damage/flash events → CounterQuant CS2 Bronze
  • Elo ratings / ML feature vectors → CounterQuant CS2 GoldLite
  • Polymarket odds / market intelligence → Private, never released
  • Model predictions / proprietary embeddings → Private, never released

Planned File Structure 

data/
├── matches/
│   ├── matches_2012_2019.parquet        # Historical batch
│   ├── matches_2020_2023.parquet        # Recent historical batch
│   ├── matches_2024.parquet             # First public release
│   └── matches_2025.parquet            # Released 2027
├── maps/
│   ├── maps_2024.parquet
│   └── ...
├── player_stats/
│   ├── player_stats_2024.parquet
│   └── ...
├── events/
│   ├── events_2024.parquet
│   └── events_all.parquet               # Full event directory
├── players.parquet                      # Reference table, all time
├── teams.parquet                        # Reference table, all time
├── rosters/
│   ├── rosters_2024.parquet
│   └── ...
└── vetoes/
    ├── vetoes_2024.parquet
    └── ...

Schema Reference

matches_YYYY.parquet

One row per match series (bo1, bo2, bo3, bo5).

Column Type Description
match_id int64 HLTV match ID
event_id int64 Event this match belongs to
event_name string Event name (denormalized for convenience)
team1_id int64 HLTV team ID
team1_name string Team 1 name (denormalized)
team2_id int64 HLTV team ID
team2_name string Team 2 name (denormalized)
winner_id int64 HLTV team ID of the winner (null if not completed)
winner_name string Winner name (denormalized)
format string bo1, bo2, bo3, bo5
team1_maps_won int16 Maps won by team 1
team2_maps_won int16 Maps won by team 2
date date Match date (UTC)
tier int16 1 = Major-level, 2 = Challenger, 3 = Regional
is_lan bool True if played on LAN
event_stage string Group stage, playoffs, grand final, etc.

maps_YYYY.parquet

One row per individual map within a match series.

Column Type Description
map_id int64 Internal map ID
match_id int64 Parent match ID
map_number int16 Map index within the series (1, 2, 3…)
map_name string CS2 map name (de_mirage, de_dust2, etc.)
team1_id int64 Team 1 HLTV ID
team2_id int64 Team 2 HLTV ID
winner_id int64 ID of the map winner
team1_score int16 Final score team 1
team2_score int16 Final score team 2
team1_ct_score int16 Team 1 rounds won on CT side
team2_ct_score int16 Team 2 rounds won on CT side
team1_t_score int16 Team 1 rounds won on T side
team2_t_score int16 Team 2 rounds won on T side
went_overtime bool True if map went to overtime
pick_team_id int64 Which team picked this map (null for decider)
pick_type string pick, ban_remaining (decider)

player_stats_YYYY.parquet

Per-player performance statistics for each map played.

Column Type Description
stat_id int64 Internal stat row ID
match_id int64 Match ID
map_id int64 Map ID
map_name string CS2 map name (denormalized)
player_id int64 Internal player ID
player_ign string In-game name at time of match
steam64_id int64 Steam 64-bit ID (null if unknown)
team_id int64 Team ID the player was on
kills int16 Total kills
deaths int16 Total deaths
assists int16 Total assists
headshot_kills int16 Headshot kills
kast float32 Kill/Assist/Survived/Traded percentage (0–1)
adr float32 Average damage per round
rating_2 float32 HLTV Rating 2.0
opening_kills int16 Opening duels won
opening_deaths int16 Opening duels lost
clutches_won int16 1vX clutch rounds won
clutches_attempted int16 1vX clutch rounds attempted

events_YYYY.parquet

Column Type Description
event_id int64 HLTV event ID
name string Full event name
short_name string Abbreviated name
start_date date Event start date
end_date date Event end date
prize_pool_usd int32 Prize pool in USD (null if unknown)
location string City, Country
country_code string ISO 3166-1 alpha-1 country code
tier int16 HLTV event tier
organizer string Organizing body (ESL, PGL, BLAST, etc.)
is_lan bool True if LAN event
event_type string major, iem, epl, qualifier, regional, etc.

players.parquet (reference, all years)

Column Type Description
player_id int64 Internal player ID
ign string Current in-game name
real_name string Player's real name
nationality string Country code
birth_year int16 Year of birth
hltv_id int64 HLTV player profile ID
steam64_id int64 Steam 64-bit ID
liquipedia_id string Liquipedia profile slug

teams.parquet (reference, all years)

Column Type Description
team_id int64 Internal team ID
name string Team name
hltv_id int64 HLTV team ID
region string Region (EU, NA, CIS, Asia, SA, OCE)

rosters_YYYY.parquet

Player–team assignment history. One row per player–team stint.

Column Type Description
player_id int64 Player ID
team_id int64 Team ID
joined_date date Approximate roster join date (null if unknown)
role string rifler, awper, igl, support, lurker

vetoes_YYYY.parquet

Map veto sequences for bo3 and bo5 matches.

Column Type Description
match_id int64 Match ID
veto_idx int16 Step index (1, 2, 3…)
team_id int64 Team making the veto action
action string ban, pick, left (random remaining map)
map_name string CS2 map name

Quick Start (Preview)

Once 2024 data is published, loading will look like this:

import polars as pl
from huggingface_hub import hf_hub_download

# Download 2024 match results
path = hf_hub_download(
    repo_id="KEDevO/CounterQuant-CS2-Silver",
    repo_type="dataset",
    filename="data/matches/matches_2024.parquet",
)
matches = pl.read_parquet(path)
print(f"2024 matches: {len(matches)}")

# Download 2024 player stats
stats_path = hf_hub_download(
    repo_id="KEDevO/CounterQuant-CS2-Silver",
    repo_type="dataset",
    filename="data/player_stats/player_stats_2024.parquet",
)
stats = pl.read_parquet(stats_path)

import duckdb

# Top players by average rating across 2024 Tier 1 maps
conn = duckdb.connect()
result = conn.execute("""
    SELECT
        s.player_ign,
        COUNT(*) AS maps_played,
        ROUND(AVG(s.rating_2), 3) AS avg_rating,
        ROUND(AVG(s.adr), 1) AS avg_adr,
        ROUND(AVG(s.kast) * 100, 1) AS kast_pct
    FROM read_parquet('data/player_stats/player_stats_2024.parquet') s
    JOIN read_parquet('data/matches/matches_2024.parquet') m USING (match_id)
    WHERE m.tier = 1
    GROUP BY s.player_ign
    HAVING maps_played >= 20
    ORDER BY avg_rating DESC
    LIMIT 20
""").fetchdf()
print(result)

# Map pool analysis — team win rates per map in 2024
result = conn.execute("""
    SELECT
        t.name AS team,
        s.map_name,
        COUNT(*) AS maps_played,
        SUM(CASE WHEN mp.winner_id = mp.team1_id THEN 1 ELSE 0 END) AS wins,
        ROUND(SUM(CASE WHEN mp.winner_id = mp.team1_id THEN 1.0 ELSE 0.0 END) / COUNT(*), 3) AS win_rate
    FROM read_parquet('data/maps/maps_2024.parquet') mp
    JOIN read_parquet('data/teams.parquet') t ON t.team_id = mp.team1_id
    GROUP BY t.name, mp.map_name
    HAVING maps_played >= 5
    ORDER BY win_rate DESC
""").fetchdf()

Data Collection Methodology

Sources

  • HLTV.org — Primary source for match results, map scores, player statistics, events, and match metadata. Scraped via authenticated HTTP requests with proxy rotation. Match pages are scraped with Puppeteer to extract structured stat tables.
  • Liquipedia — Supplementary source for player real names, nationalities, birth years, event metadata, and roster history. Used to fill gaps in HLTV data.

Normalization

All data is stored in a normalized PostgreSQL schema on CounterQuant's infrastructure before export to Parquet. Entity resolution (matching HLTV IDs with Liquipedia IDs, resolving player name changes, handling team rebrandings) is handled during ingestion.

Player rating

The rating_2 column uses HLTV's proprietary Rating 2.0 formula as scraped from match pages. CounterQuant does not independently compute Rating 2.0 — the value is the one HLTV publishes on their match statistics pages.

Known limitations

  • Rating gaps: Not all historical match pages have complete per-player rating data. Rows with missing rating have rating_2 = null.
  • Roster dating: Roster join dates are approximate. Some early transfers have only month-level precision.
  • Overnight matches: A small number of matches crossing midnight UTC may have off-by-one dates.
  • Team name changes: Team names are recorded at time of match. Historical names (NaVi vs Natus Vincere, etc.) are normalized to current canonical names where possible.

Match Coverage by Year

Year Matches Maps Tier 1 Fraction Notes
2024 ~9,248 ~18,500 ~20% First public release — Q3 2026
2025 ~10,336 ~20,600 ~20% Released 2027 (2-year delay)
2023 ~10,200 ~20,400 ~20% Backfill — included in 2012–2023 batch
2020–2022 ~25,000 ~50,000 ~15% Backfill
2015–2019 ~30,000 ~60,000 ~10% Backfill, CS:GO era
2012–2014 ~12,000 ~24,000 ~8% Backfill, early CS:GO

Historical match counts are estimates based on current HLTV coverage. Exact counts will be published with each data release.

Related Datasets

Dataset Contents Relationship
CounterQuant CS2 Demos Raw .dem files Source layer — parse yourself for custom event extraction
CounterQuant CS2 Bronze Tick-level kill/damage/flash/utility events Event-level layer — join on match_id to enrich Silver stats
CounterQuant CS2 GoldLite Elo ratings, form, head-to-head, event context features Derived from Silver — ML-ready feature tables
CounterQuant Platform Live dashboard, player ratings, predictions, API Production platform built on the full data stack
CounterQuant API REST API for real-time and historical data access API access to Silver and Gold data layers

Data Release Policy

Layer Public? Timeline
Silver 2024 ✅ CC BY 4.0 Q3 2026
Silver 2012–2023 ✅ CC BY 4.0 Q4 2026 (backfill)
Silver 2025 ✅ CC BY 4.0 2027 (2-year delay)
Silver 2026+ ⏳ Delayed 2028+ (2-year delay)
Elo / feature vectors See GoldLite Partial public, demo-derived features private
Market intelligence ❌ Private Never released
Model predictions ❌ Private Never released
Proprietary embeddings ❌ Private Never released

Citation

If you use this dataset in research, analytics products, or publications, please cite:

BibTeX 

@dataset{kulbe2026counterquantsilver,
  author       = {Eimantas Kulbe},
  title        = {CounterQuant CS2 Silver: Normalized Professional CS2 Match \& Player Statistics},
  year         = {2026},
  publisher    = {Hugging Face},
  url          = {https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Silver},
  note         = {Canonical match results, per-map scores, player statistics,
                  event metadata, rosters, and veto sequences for professional
                  CS2 matches from 2012 to present. Sourced from HLTV and Liquipedia.}
}

APA

Kulbe, E. (2026). CounterQuant CS2 Silver: Normalized Professional CS2 Match & Player Statistics [Dataset]. Hugging Face. https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Silver

Acknowledgement (for papers/articles)

Match results and player statistics sourced from CounterQuant CS2 Silver (Kulbe, 2026), available at https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Silver under CC BY 4.0.

License

Creative Commons Attribution 4.0 International (CC BY 4.0)

You are free to:

  • Share — copy and redistribute the material in any medium or format
  • Adapt — remix, transform, and build upon the material for any purpose, including commercial

Under the condition that you give appropriate credit to Eimantas Kulbe and link back to this dataset.

Full license text: https://creativecommons.org/licenses/by/4.0/

Dataset maintained by Eimantas Kulbe. For questions, issues, or collaboration: open a discussion on this dataset page or reach out via CounterQuant.
Downloads last month
23
Total file size:
21 kB