KEDevO/CounterQuant-CS2-Bronze

CounterQuant CS2 Bronze

Institutional-grade, event-level CS2 competitive match data — kill-by-kill, bullet-by-bullet, utility-by-utility.

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

Parsed from raw .dem files in CounterQuant CS2 Demos using demoparser2 and awpy. Covers Tier 1, Tier 2, and Tier 3 professional CS2 matches from January 2024 to present. Continuously updated as new demos are parsed.

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

---

Dataset at a Glance

Metric	Value
Matches with demos	6,620+
Matches fully parsed	3,098 (growing)
Kill events extracted	2.8M+
Damage events extracted	5.1M+
Player-round KAST rows	1.4M+
Time period	January 2024 – present
Tiers	T1, T2, T3 professional
Update cadence	Continuous (new demos within 24–48h of match)
Parse engine	demoparser2 0.41.3 + awpy 2.x
Format	Parquet (Snappy compression)
License	CC BY 4.0

---

Motivation

CS2 demo data has historically been locked behind proprietary tools, expensive data providers, or limited to aggregated statistics. This dataset provides tick-level event granularity — every kill, every bullet, every flash and smoke detonation — for thousands of professional matches, freely available for research, analytics, and model training.

The goal is to enable a generation of open, reproducible esports science: utility efficiency models, economy decision trees, clutch probability estimators, positional advantage metrics, and player rating systems that go far beyond K/D.

---

Current State & Roadmap

This dataset is actively being built. Parsing is continuous — new matches are processed automatically as demos become available.

Data Layer	Status	Notes
Kill events (data/kills/)	✅ Live, growing	2026 T1 populated; 2024–2025 backfill in progress
Damage events (data/damages/)	✅ Live, growing	Same coverage as kills
Flash/blind events (data/blinds/)	✅ Live, growing	Per player per blind event
Utility events (data/utility/)	✅ Live, growing	Grenades + bomb plants/defuses
Round economy snapshots	🔄 PostgreSQL → Parquet planned	Buy types, equip value, cash
Aggregated match stats	🔄 Planned	matches_{year}.parquet, maps_{year}.parquet
Player directory	🔄 Planned	players_{year}.parquet with HLTV IDs
Team directory	🔄 Planned	teams_{year}.parquet
KAST/Player-round stats	🔄 PostgreSQL → Parquet planned	Computed from kills + survival

Aggregated stat files (matches, maps, players) will be published once per-year coverage reaches completeness. Current event parquets are the ground truth from which all aggregates derive.

---

File Structure

data/
├── kills/
│   ├── 2024/
│   │   ├── tier1/
│   │   │   └── {match_id}/
│   │   │       └── {map_name}.parquet
│   │   ├── tier2/
│   │   └── tier3/
│   ├── 2025/
│   └── 2026/
├── damages/         # same structure as kills/
├── blinds/          # same structure as kills/
└── utility/         # same structure as kills/

Example paths:

data/kills/2026/tier1/2392553/de_mirage.parquet
data/damages/2025/tier2/2341200/de_nuke.parquet
data/utility/2024/tier1/2289100/de_inferno.parquet

---

Schema Reference

data/kills/ — Kill Events (player_death)

Each row is one kill event extracted from a professional CS2 demo.

Column	Type	Description
match_id	int64	HLTV match ID
map_name	string	CS2 map name (e.g. de_mirage)
tick	int64	Demo tick when kill occurred
round	int32	Round number (1-indexed)
attacker_steamid	int64	Steam ID of the killer
attacker_name	string	IGN of the killer
attacker_team_num	int32	2 = T-side, 3 = CT-side
victim_steamid	int64	Steam ID of the victim
victim_name	string	IGN of the victim
victim_team_num	int32	2 = T-side, 3 = CT-side
weapon	string	Weapon used (e.g. ak47, awp)
headshot	bool	True if headshot
thrusmoke	bool	True if kill through smoke
noscope	bool	True if AWP no-scope
attackerblind	bool	True if attacker was blinded
penetrated	int32	Bullets that penetrated walls
dominated	bool	True if attacker dominated victim
revenge	bool	True if revenge kill
distance	float32	Distance between attacker and victim (game units)
assister_steamid	int64	Steam ID of assist (null if none)
assister_name	string	IGN of assister
assistedflash	bool	True if assist was a flash-assist
attacker_X	float32	Attacker world X coordinate
attacker_Y	float32	Attacker world Y coordinate
attacker_Z	float32	Attacker world Z coordinate (elevation)
victim_X	float32	Victim world X coordinate
victim_Y	float32	Victim world Y coordinate
victim_Z	float32	Victim world Z coordinate

---

data/damages/ — Damage Events (player_hurt)

Each row is one damage event (bullet hit, grenade damage, etc.).

Column	Type	Description
match_id	int64	HLTV match ID
map_name	string	Map name
tick	int64	Demo tick
round	int32	Round number
attacker_steamid	int64	Steam ID of attacker
attacker_name	string	IGN
attacker_team_num	int32	2 = T, 3 = CT
victim_steamid	int64	Steam ID of victim
victim_name	string	IGN
victim_team_num	int32	2 = T, 3 = CT
weapon	string	Weapon / grenade type
dmg_health	int32	Health damage dealt
dmg_armor	int32	Armor damage dealt
hitgroup	int32	Hit location code (0=generic, 1=head, 2=chest, 3=stomach, 4=L-arm, 5=R-arm, 6=L-leg, 7=R-leg)

---

data/blinds/ — Flash Blind Events (player_blind)

Each row is one flash blindness event — a player being blinded by a flashbang.

Column	Type	Description
match_id	int64	HLTV match ID
map_name	string	Map name
tick	int64	Demo tick
steamid	int64	Steam ID of blinded player
name	string	IGN
team_num	int32	2 = T, 3 = CT
blind_duration	float32	Duration of blindness in seconds
attacker_steamid	int64	Steam ID of flash thrower
attacker_name	string	Flash thrower IGN
attacker_team_num	int32	2 = T, 3 = CT

---

data/utility/ — Utility & Bomb Events

Combined parquet of all grenade detonations and bomb lifecycle events per map.

Column	Type	Description
match_id	int64	HLTV match ID
map_name	string	Map name
tick	int64	Demo tick
round	int32	Round number
steamid	int64	Steam ID of thrower / planter
name	string	IGN
team_num	int32	2 = T, 3 = CT
X	float32	World X at detonation/plant
Y	float32	World Y at detonation/plant
Z	float32	World Z at detonation/plant
nade_type	string	hegrenade, inferno, smokegrenade, decoy, flashbang (null for bomb events)
event_type	string	bomb_planted, bomb_defused, bomb_exploded (null for grenade events)

---

Match Coverage

Year	Tier 1	Tier 2	Tier 3	Total
2024	811	1,252	342	2,405
2025	817	900	398	2,115
2026	220	1,044	836	2,100
Total	1,848	3,196	1,576	6,620

Coverage as of May 2026. Parsing is continuous — parquet files are added as demos are processed.

Tier definitions (HLTV classification):

• Tier 1 — Major-qualifier and above (IEM Katowice, PGL Major, ESL Pro League, etc.)
• Tier 2 — ESL Challenger, CCT, ESEA Premier, regional qualifiers
• Tier 3 — Open qualifiers, community tournaments, regional leagues

---

Quick Start

Load all kills for a specific match

import polars as pl
from huggingface_hub import hf_hub_download

# Download a single match's kill events
path = hf_hub_download(
    repo_id="KEDevO/CounterQuant-CS2-Bronze",
    repo_type="dataset",
    filename="data/kills/2026/tier1/2392553/de_mirage.parquet",
)
df = pl.read_parquet(path)
print(df.shape)  # (kills, columns)
print(df.head())

Bulk download by year and tier

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="KEDevO/CounterQuant-CS2-Bronze",
    repo_type="dataset",
    allow_patterns="data/kills/2025/tier1/**",
    local_dir="./bronze_kills_2025_t1",
    resume_download=True,
)

Query across matches with DuckDB

import duckdb

conn = duckdb.connect()
result = conn.execute("""
    SELECT
        attacker_name,
        COUNT(*) AS kills,
        ROUND(AVG(distance), 1) AS avg_distance,
        SUM(headshot::INT) / COUNT(*) AS hs_rate,
        SUM(thrusmoke::INT) AS smoke_kills
    FROM read_parquet('bronze_kills_2025_t1/**/*.parquet', hive_partitioning=false)
    GROUP BY attacker_name
    ORDER BY kills DESC
    LIMIT 20
""").fetchdf()
print(result)

Compute ADR per player per round

import polars as pl

dmg = pl.read_parquet("data/damages/2025/tier1/**/*.parquet")

adr = (
    dmg
    .group_by(["match_id", "map_name", "attacker_steamid", "attacker_name", "round"])
    .agg(pl.sum("dmg_health").alias("dmg"))
    .group_by(["match_id", "map_name", "attacker_steamid", "attacker_name"])
    .agg(pl.mean("dmg").alias("adr"))
    .sort("adr", descending=True)
)

Flash efficiency analysis

import polars as pl

blinds = pl.read_parquet("data/blinds/2025/tier1/**/*.parquet")

flash_stats = (
    blinds
    # Enemy flashes only: attacker_team_num != victim team_num
    .filter(pl.col("attacker_team_num") != pl.col("team_num"))
    .group_by(["attacker_steamid", "attacker_name"])
    .agg([
        pl.count().alias("enemies_flashed"),
        pl.mean("blind_duration").alias("avg_blind_duration"),
    ])
    .sort("enemies_flashed", descending=True)
)

---

Data Collection Methodology

Demo sourcing

Raw .dem files are sourced from HLTV.org's demo CDN ([match_id].rar archives) via authenticated requests with proxy rotation. Demos are stored verbatim in CounterQuant CS2 Demos before parsing.

Parsing pipeline

Each .dem file is parsed on dedicated hardware using:

• demoparser2 0.41.3 — Rust-native CS2 demo parser. Used to extract player_death, player_hurt, player_blind, grenade/bomb events, and economy snapshots at round freeze ticks.
• awpy 2.x — For KAST computation (Kill/Assist/Survived/Traded) and complementary round-level player statistics.

Parse version

All files in this dataset are produced by parser version v3. Parse version is tracked in the internal demo_parse_log table. If parsing methodology changes significantly, new versioned files will be added without removing existing ones.

Known limitations

• Warmup rounds: Some very early rounds (pre-round 1) may contain warmup kills. Filter by round >= 1.
• Overtime: Overtime rounds are included. Standard maps run 24 rounds; anything beyond is overtime.
• Team side assignment: team_num=2 is always T-side at that point in the match; sides swap at halftime. Map-level side assignment requires joining with round economy context.
• Missing demos: Not all HLTV matches have publicly available demo files. Matches without demos are excluded from this dataset.
• Parse failures: A small number of demos (~2%) fail to parse due to corruption or early termination. These are tracked internally but absent from the dataset.

---

The CounterQuant Data Stack

Bronze is one layer in a four-tier public data release. All layers share the same match IDs for easy joining:

Tier	Dataset	Contents	Status
Raw demos	CounterQuant CS2 Demos	Raw files	Live
Bronze <- this dataset	-	Tick-level events: kills, damages, flashes, utility	Live, growing
Silver	CounterQuant CS2 Silver	Normalized match results, map scores, player stats, rosters, events	Staging for export
Gold Lite	CounterQuant CS2 GoldLite	ML-ready features: Elo, form, H2H, event context	Staging for export

Typical join pattern: Load Bronze kill events -> join on to Silver for tier/event context or to Silver for per-map stat cross-referencing.

Related Datasets & Resources

Resource	Description
CounterQuant CS2 Demos	Raw files - parse them yourself, or use this Bronze dataset
CounterQuant CS2 Silver	Normalized match results, map scores, player stats - join on
CounterQuant CS2 GoldLite	ML-ready Elo/form/H2H features - extend with Bronze-derived demo features
CounterQuant Platform	Live analytics dashboard, player ratings, match predictions, API
CounterQuant API	REST API for programmatic access to match data, player stats, feature vectors

---

Data Release Policy

Layer	Public?	Notes
Raw event parquets (this dataset)	✅ CC BY 4.0	Kills, damages, blinds, utility
Aggregated bronze stats	✅ CC BY 4.0	matches/maps/players — planned
Feature vectors	❌ Private	509-feature ML pipeline, CounterQuant platform only
Match outcome predictions	❌ Private	XGBoost / LightGBM model outputs
Live odds / market data	❌ Private	Polymarket integration, never released
Model weights	❌ Private	Proprietary ML models

---

Citation

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

BibTeX

@dataset{kulbe2026counterquantbronze,
  author       = {Eimantas Kulbe},
  title        = {CounterQuant CS2 Bronze: Event-Level Professional Match Data},
  year         = {2026},
  publisher    = {Hugging Face},
  url          = {https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Bronze},
  note         = {Continuously updated CS2 kill, damage, utility and economy event dataset
                  parsed from professional HLTV demos. Tier 1--3 matches, 2024--present.}
}

APA

Kulbe, E. (2026). CounterQuant CS2 Bronze: Event-Level Professional Match Data [Dataset]. Hugging Face. https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Bronze

Acknowledgement (for papers/articles)

Kill event and economy data sourced from CounterQuant CS2 Bronze (Kulbe, 2026), available at https://huggingface.co/datasets/KEDevO/CounterQuant-CS2-Bronze 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.