{"id":3971,"date":"2026-09-21T10:00:00","date_gmt":"2026-09-21T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=3971"},"modified":"2026-09-10T13:27:34","modified_gmt":"2026-09-10T13:27:34","slug":"cs2-odds-api","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/cs2-odds-api\/","title":{"rendered":"CS2 Odds API: Resolve the Map Handicap Across 15 Market IDs"},"content":{"rendered":"

Pull one Counter-Strike 2 match off the OddsPapi CS2 odds API<\/strong> and you get a wide board. Magic v Alliance at FISSURE Playground on 10 September 2026 returned 155 bookmakers<\/strong>. Another PGL Masters Bucharest fixture returned 149. Across 41 CS2 fixtures with odds in a nine-day window, the median was 91 books.<\/p>\n

Then you parse it, and the same market name comes back fifteen times. Maps Handicap<\/code> is fifteen separate market IDs, one per rung from -3.5 to +3.5. Total Maps Over Under<\/code> is another seven, from 2.5 to 8.5. The line that separates them sits in the handicap<\/code> field of \/v4\/markets<\/code>, not in the price object. Key your parser on the market name and you merge fifteen different bets into one.<\/p>\n

What the CS2 Catalogue Holds<\/h2>\n

Counter-Strike 2 is sportId<\/code> 17. Its catalogue is 28 market IDs, and 22 of them belong to the two ladders. Every number in this post comes from live calls made on 10 September 2026.<\/p>\n

\n\n\n\n\n\n\n\n\n
Market name<\/th>\nMarket IDs<\/th>\nLines<\/th>\nPeriod<\/th>\n<\/tr>\n<\/thead>\n
Winner<\/td>\n171<\/code><\/td>\n0.0<\/td>\nseries<\/td>\n<\/tr>\n
Total Maps Over Under<\/td>\n173<\/code>, 175<\/code>, 177<\/code>, 179<\/code>, 1711<\/code>, 1713<\/code>, 1715<\/code><\/td>\n2.5 to 8.5<\/td>\nseries<\/td>\n<\/tr>\n
Maps Handicap<\/td>\n1717<\/code> to 1745<\/code>, odd numbers<\/td>\n-3.5 to +3.5 in 0.5 steps<\/td>\nseries<\/td>\n<\/tr>\n
First to Fifth Map Winner (incl. overtime)<\/td>\n1747<\/code>, 1749<\/code>, 1751<\/code>, 1753<\/code>, 1755<\/code><\/td>\n0.0<\/td>\np1 to p5<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

This is the mirror image of the trap in our boxing odds API post<\/a>. There, three market IDs carry the same bet and you merge them. Here, fifteen IDs share one name and carry fifteen different bets, so you split them on handicap<\/code> and keep them apart.<\/p>\n

Old Way vs OddsPapi<\/h2>\n
\n\n\n\n\n\n\n\n\n\n\n
Task<\/th>\nScraping two or three sportsbooks<\/th>\nOddsPapi \/v4<\/code><\/th>\n<\/tr>\n<\/thead>\n
Books on a tier-1 CS2 match<\/td>\n2 to 3<\/td>\nUp to 155, median 91 across 41 fixtures<\/td>\n<\/tr>\n
Map handicap ladder<\/td>\nReverse-engineer each site’s HTML<\/td>\n15 market IDs with a typed handicap<\/code> value<\/td>\n<\/tr>\n
Sharp anchor<\/td>\nPinnacle, if the page loads<\/td>\nPinnacle, Kalshi, Polymarket and Betfair Exchange in one payload<\/td>\n<\/tr>\n
Grading a finished Bo3<\/td>\nWrite your own rules per market<\/td>\n\/v4\/settlements<\/code> returns WIN, LOSE or PUSH per outcome<\/td>\n<\/tr>\n
Historical prices<\/td>\nLog it yourself from today<\/td>\nFree, every recorded snapshot, three books per call<\/td>\n<\/tr>\n
Cost to start<\/td>\nYour weekends<\/td>\nFree tier, no card<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Step 1: Find the Circuits That Are Running<\/h2>\n

Do not discover CS2 events from \/v4\/tournaments<\/code>. The endpoint returned 350 CS2 tournament rows on 10 September and marked four of them with futureFixtures > 0<\/code>. Eleven circuits had fixtures on the nine-day window, and ten of those eleven reported futureFixtures<\/code> as zero, PGL Masters Bucharest among them. Group \/v4\/fixtures<\/code> on tournamentId<\/code> instead.<\/p>\n

import os, requests, collections, datetime as dt\n\nAPI_KEY = os.environ[\"ODDSPAPI_API_KEY\"]\nBASE = \"https:\/\/api.oddspapi.io\/v4\"\nCS2 = 17\n\ntoday = dt.date.today()\nr = requests.get(f\"{BASE}\/fixtures\", params={\n    \"apiKey\": API_KEY, \"sportId\": CS2,\n    \"from\": today.isoformat(),\n    \"to\": (today + dt.timedelta(days=9)).isoformat(),\n})\nr.raise_for_status()\nfixtures = r.json()\n\ncircuits = collections.Counter(\n    (f[\"tournamentId\"], f[\"tournamentName\"]) for f in fixtures\n)\nprint(f\"{len(fixtures)} fixtures, {sum(1 for f in fixtures if f['hasOdds'])} with odds\")\nfor (tid, name), n in circuits.most_common():\n    print(f\"  {n:>3}  {name}  ({tid})\")<\/code><\/pre>\n
Output on 10 September 2026:<\/p>\n
50 fixtures, 41 with odds\n   11  PGL Masters Bucharest  (49212)\n    8  FISSURE Playground  (46097)\n    8  Thunderpick World Championship  (41296)\n    6  CCT European Series  (51122)\n    4  United21  (44609)\n    4  CCT Contenders Europe  (51054)\n    3  CCT Europe Challengers  (51210)\n    2  1win Private Club  (52934)\n    2  ESEA League Europe  (51004)\n    1  NODWIN Clutch Series  (49568)\n    1  NSTLGA League  (51976)<\/code><\/pre>\n
Two constraints on that call. Without a tournamentId<\/code>, a from<\/code>\/to<\/code> range wider than ten days returns 400 INVALID_PARAMETER<\/code>. And to<\/code> is a midnight-UTC instant, so set it to the day after the last day you want.<\/p>\n
Step 2: Build the Ladder Map<\/h2>\n
The sportId<\/code> parameter on \/v4\/markets<\/code> is a no-op. The endpoint returns all 33,115 definitions and you filter client-side. Each row carries marketName<\/code>, handicap<\/code>, period<\/code> and the outcome list, and the pair (marketName, handicap)<\/code> is what identifies the bet.<\/p>\n
catalogue = requests.get(f\"{BASE}\/markets\", params={\"apiKey\": API_KEY}).json()\ncs2 = {str(m[\"marketId\"]): m for m in catalogue if m[\"sportId\"] == CS2}\n\nfor mid, m in sorted(cs2.items(), key=lambda kv: (kv[1][\"marketName\"], kv[1][\"handicap\"])):\n    print(f\"  {mid:>5}  {m['marketName']:<34} line {m['handicap']:>5}  period {m['period']}\")\n\nhandicaps = {m[\"handicap\"]: mid for mid, m in cs2.items()\n             if m[\"marketName\"] == \"Maps Handicap\"}\ntotals = {m[\"handicap\"]: mid for mid, m in cs2.items()\n          if m[\"marketName\"] == \"Total Maps Over Under\"}\nprint(\"Maps Handicap rungs:\", sorted(handicaps))\nprint(\"Total Maps rungs:   \", sorted(totals))<\/code><\/pre>\n
28 Counter-Strike 2 market IDs\n   1717  Maps Handicap                      line  -3.5  period result\n   1719  Maps Handicap                      line  -3.0  period result\n   ...\n   1745  Maps Handicap                      line   3.5  period result\n    173  Total Maps Over Under              line   2.5  period result\n    ...\n    171  Winner                             line   0.0  period result\n\nMaps Handicap rungs: [-3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5]\nTotal Maps rungs:    [2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]<\/code><\/pre>\n
Read the outcome names from the catalogue too. The two legs of Maps Handicap<\/code> are named 1<\/code> and 2<\/code>, and their order inside the outcomes<\/code> array flips between rungs. Market 1717<\/code> lists outcome 1718 first; market 1725<\/code> lists outcome 1725 first. Match on outcomeName<\/code> and never on array position.<\/p>\n
Step 3: Read the Board<\/h2>\n
One \/v4\/odds<\/code> call returns every book on the fixture. Three filters turn the raw payload into quotes you can price against: the book-level suspended<\/code> flag, the market-level marketActive<\/code> flag, and the price-level active<\/code> flag. Drop any slug containing +<\/code> and the demo<\/code> slug as well, because those are internal test feeds.<\/p>\n
import statistics\n\ndef read_board(fixture_id, catalogue):\n    \"\"\"Return {market_id: {slug: {outcome_id: price}}} for two-sided active quotes.\"\"\"\n    r = requests.get(f\"{BASE}\/odds\",\n                     params={\"apiKey\": API_KEY, \"fixtureId\": fixture_id})\n    r.raise_for_status()\n    board = {}\n    for slug, book in (r.json().get(\"bookmakerOdds\") or {}).items():\n        if \"+\" in slug or slug == \"demo\":\n            continue\n        if book.get(\"suspended\"):\n            continue\n        for mid, market in (book.get(\"markets\") or {}).items():\n            if not market.get(\"marketActive\"):\n                continue\n            legs = {}\n            for oid, outcome in (market.get(\"outcomes\") or {}).items():\n                price = (outcome.get(\"players\") or {}).get(\"0\")\n                if price and price.get(\"active\") and price.get(\"price\"):\n                    legs[oid] = price[\"price\"]\n            if len(legs) == len(catalogue[mid][\"outcomes\"]):\n                board.setdefault(mid, {})[slug] = legs\n    return board\n\nboard = read_board(\"id1704921274528890\", cs2)   # Fluxo v Dendele, PGL Masters Bucharest\n\nfor mid, quotes in sorted(board.items(), key=lambda kv: -len(kv[1])):\n    m = cs2[mid]\n    tuples = {tuple(sorted(q.items())) for q in quotes.values()}\n    margins = [sum(1 \/ p for p in q.values()) - 1 for q in quotes.values()]\n    print(f\"{mid:>5} {m['marketName']:<34} line {m['handicap']:>5} | \"\n          f\"{len(quotes):>3} books -> {len(tuples):>3} distinct | \"\n          f\"median margin {100 * statistics.median(margins):.2f}%\")<\/code><\/pre>\n
Fluxo v Dendele carried 134 books and 26 market IDs. After the three filters, seven markets survive:<\/p>\n
  171 Winner                             line   0.0 | 132 books ->  21 distinct | median margin 7.96%\n 1749 Second Map Winner (incl. overtime) line   0.0 | 124 books ->  22 distinct | median margin 6.99%\n 1747 First Map Winner (incl. overtime)  line   0.0 | 124 books ->  21 distinct | median margin 6.99%\n  173 Total Maps Over Under              line   2.5 | 120 books ->  22 distinct | median margin 7.19%\n 1737 Maps Handicap                      line   1.5 | 118 books ->  21 distinct | median margin 7.93%\n 1725 Maps Handicap                      line  -1.5 |  81 books ->  14 distinct | median margin 8.15%\n 1751 Third Map Winner (incl. overtime)  line   0.0 |  65 books ->  13 distinct | median margin 7.07%<\/code><\/pre>\n
Those seven are the series markets a best-of-three can settle: the winner, the 2.5 map total, the +\/-1.5 map handicap, and a winner for each of the three maps. Across 18 pre-match CS2 fixtures measured on 10 September, they ran 97.1% active<\/strong>, or 12,266 live prices out of 12,634. The other nineteen rungs of the two ladders carried 5,258 posted prices across those same 18 fixtures and none of them was flagged active<\/code>. The active<\/code> filter is what separates a tradeable board from a menu. Our NFL alternate lines post<\/a> runs the same measurement on a 1,679-market American football board.<\/p>\n
Note the dedupe line. 132 distinct slugs quoted the Fluxo v Dendele winner and they collapse to 21 distinct price tuples, an 84% collapse. Across 14 deep boards the median collapse was 72%. Count books before you dedupe and a consensus price counts one trading desk twenty times. The cloneOf<\/code> field does not catch this, so compare the price tuple itself.<\/p>\n
Step 4: Find the Tight Prices<\/h2>\n
Margin ranking works on any two-legged market and does not care which leg is which: 1\/a + 1\/b - 1<\/code>. Run it across 14 deep CS2 boards and the prediction markets sit at the top.<\/p>\n
\n\n\n\n\n\n\n\n\n\n\n
Bookmaker<\/th>\nFixtures quoted (of 14)<\/th>\nMedian margin on market 171<\/code><\/th>\n<\/tr>\n<\/thead>\n
polymarket.us<\/code><\/td>\n11<\/td>\n1.00%<\/td>\n<\/tr>\n
polymarket<\/code><\/td>\n10<\/td>\n1.01%<\/td>\n<\/tr>\n
kalshi<\/code><\/td>\n9<\/td>\n1.03%<\/td>\n<\/tr>\n
duel<\/code><\/td>\n12<\/td>\n3.49%<\/td>\n<\/tr>\n
1xbet<\/code><\/td>\n14<\/td>\n5.41%<\/td>\n<\/tr>\n
Board median, 63 books<\/td>\n–<\/td>\n6.46%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Polymarket and Kalshi appeared on all 14 boards, Pinnacle on 7 and Betfair Exchange on 3. On esports the prediction markets are the anchor you can rely on being there, which is the same pattern our League of Legends odds API post<\/a> found on the LEC and LCK board. De-vig the deduped consensus rather than any single book, and use the consensus odds method<\/a> to get there.<\/p>\n
Step 5: Grade the Ladder<\/h2>\n
\/v4\/scores<\/code> returns the map score of a finished series, and \/v4\/settlements<\/code> returns WIN, LOSE or PUSH for every outcome. Together they let you check your own handicap logic against the feed before you trust it on money.<\/p>\n
The rule for Maps Handicap<\/code> is one line. Add the market’s handicap<\/code> value to participant 1’s map margin. Positive is a win, negative is a loss, zero is a push.<\/p>\n
import time\n\ndef grade_handicap(map_margin, line):\n    \"\"\"map_margin = participant1 maps - participant2 maps.\"\"\"\n    edge = map_margin + line\n    return \"PUSH\" if edge == 0 else (\"WIN\" if edge > 0 else \"LOSE\")\n\nFIXTURE = \"id1704609774517440\"   # G2 Esports v 9Z Team, FISSURE Playground\n\nscores = requests.get(f\"{BASE}\/scores\",\n                      params={\"apiKey\": API_KEY, \"fixtureId\": FIXTURE}).json()\nresult = scores[\"scores\"][\"periods\"][\"result\"]\nmargin = result[\"participant1Score\"] - result[\"participant2Score\"]\nprint(f\"map score {result['participant1Score']}-{result['participant2Score']}, margin {margin:+d}\")\n\ntime.sleep(2)\nsettled = requests.get(f\"{BASE}\/settlements\",\n                       params={\"apiKey\": API_KEY, \"fixtureId\": FIXTURE}).json()\n\nfor mid, market in settled[\"markets\"].items():\n    meta = cs2[mid]\n    if meta[\"marketName\"] != \"Maps Handicap\":\n        continue\n    leg1 = next(o for o in meta[\"outcomes\"] if o[\"outcomeName\"] == \"1\")\n    feed = market[\"outcomes\"][str(leg1[\"outcomeId\"])][\"players\"][\"0\"][\"result\"]\n    mine = grade_handicap(margin, meta[\"handicap\"])\n    print(f\"  {mid:>5}  line {meta['handicap']:>5}  feed {feed:<5}  mine {mine:<5}  \"\n          f\"{'ok' if feed == mine else 'MISMATCH'}\")<\/code><\/pre>\n
G2 Esports beat 9Z Team 2-1, a margin of +1:<\/p>\n
map score 2-1, margin +1\n   1717  line  -3.5  feed LOSE   mine LOSE   ok\n   1721  line  -2.5  feed LOSE   mine LOSE   ok\n   1725  line  -1.5  feed LOSE   mine LOSE   ok\n   1727  line  -1.0  feed PUSH   mine PUSH   ok\n   1729  line  -0.5  feed WIN    mine WIN    ok\n   1737  line   1.5  feed WIN    mine WIN    ok\n   1745  line   3.5  feed WIN    mine WIN    ok\n15 handicap rungs checked<\/code><\/pre>\n
All fifteen rungs matched. The same script on Magic v Parivision, a 2-0 series, moved the push to 1723<\/code> at -2.0 and matched all fifteen again. Wrap the \/settlements<\/code> call in a retry: it returns a transient 429 under about two seconds of spacing.<\/p>\n
Step 6: Pull the History for Free<\/h2>\n
\/v4\/historical-odds<\/code> is on the free tier and returns every recorded snapshot. It takes at most three bookmakers per call, and one unreadable slug fails the whole batch, so loop three at a time. Polymarket and Betfair Exchange need one bookmaker plus exactly one outcomeId<\/code>.<\/p>\n
import datetime as dt\n\nSTART = dt.datetime(2026, 9, 10, 3, 0, tzinfo=dt.timezone.utc)\n\nr = requests.get(f\"{BASE}\/historical-odds\", params={\n    \"apiKey\": API_KEY, \"fixtureId\": FIXTURE,\n    \"bookmakers\": \"pinnacle,1xbet,stake\",\n})\nr.raise_for_status()\n\nfor slug, book in sorted(r.json()[\"bookmakers\"].items()):\n    winner = book[\"markets\"].get(\"171\")\n    if not winner:\n        continue\n    for oid, outcome in sorted(winner[\"outcomes\"].items()):\n        snaps = outcome[\"players\"][\"0\"]\n        pre = [s for s in snaps\n               if dt.datetime.fromisoformat(s[\"createdAt\"].replace(\"Z\", \"+00:00\")) < START\n               and s[\"active\"]]\n        if not pre:\n            continue\n        moves = sum(1 for a, b in zip(pre, pre[1:]) if a[\"price\"] != b[\"price\"])\n        print(f\"{slug:<10} leg {oid}  open {pre[0]['price']:<6} close {pre[-1]['price']:<6} \"\n              f\"{len(pre):>3} pre-match snapshots, {moves:>2} price changes, \"\n              f\"limit {pre[-1]['limit']}\")<\/code><\/pre>\n
1xbet      leg 171  open 1.38   close 1.34    25 pre-match snapshots,  4 price changes, limit None\n1xbet      leg 172  open 3.145  close 3.36    25 pre-match snapshots,  7 price changes, limit None\npinnacle   leg 171  open 1.375  close 1.336   36 pre-match snapshots, 30 price changes, limit 6696.0\npinnacle   leg 172  open 3.11   close 3.34    36 pre-match snapshots, 31 price changes, limit 2250.0\nstake      leg 171  open 1.35   close 1.28    62 pre-match snapshots, 13 price changes, limit None\nstake      leg 172  open 2.9    close 3.3     62 pre-match snapshots, 13 price changes, limit None<\/code><\/pre>\n
Two things to read there. Pinnacle moved its favourite 30 times in eleven hours and closed at a 6,696 limit, while 1xBet moved four times. And Stake closed the favourite at 1.28 against Pinnacle’s 1.336, a 4.2% shorter price on the same match. Filter on createdAt < startTime<\/code>, because snapshots keep arriving after the series begins, and take the last active<\/em> snapshot as the close. The limit<\/code> field is populated by Pinnacle and the exchanges, so null-check it before any arithmetic. A season of this feeds straight into a closing-line backtest<\/a>.<\/p>\n
Where to Go Next<\/h2>\n
The same 28-market shape covers every Counter-Strike circuit on the feed, from PGL Masters down to a CCT Contenders qualifier with nine books. For Dota 2, League of Legends and Valorant, swap the sportId<\/code> and re-read the catalogue, because each title carries its own ladder. Start with the esports odds API guide<\/a> for the cross-title view.<\/p>\n
If you need the board to push rather than poll, \/v4<\/code> has a WebSocket feed<\/a> that streams price changes as the books make them. Polling a 155-book CS2 payload every few seconds burns requests you do not need to spend.<\/p>\n
Start Pulling CS2 Odds<\/h2>\n
The catalogue held 357 bookmaker slugs on 10 September 2026, and 170 of them quoted at least one of the fourteen deep CS2 boards we measured. The free tier covers all of them, plus every historical snapshot, with no card and no sales call. Create a key<\/a>, run the first script in this post, and you will have the whole PGL slate in JSON inside a minute. The free odds API guide<\/a> covers the rate limits and the endpoint list.<\/p>\n
FAQ<\/h2>\n
What is the market ID for the CS2 match winner?<\/h3>\n
Market 171<\/code>, named “Winner”, with outcome 171 for participant 1 and 172 for participant 2. On Fluxo v Dendele at PGL Masters Bucharest, 132 of the 134 books on the fixture quoted it with two active legs.<\/p>\n
Why does one CS2 fixture return fifteen “Maps Handicap” markets?<\/h3>\n
Each rung of the ladder is its own market ID. IDs 1717 through 1745 cover -3.5 to +3.5 maps in 0.5 steps, and they all carry the same marketName<\/code>. Read the handicap<\/code> field from \/v4\/markets<\/code> to tell them apart, and key your parser on the pair rather than the name.<\/p>\n
How do I settle a CS2 map handicap bet?<\/h3>\n
Add the market’s handicap<\/code> value to participant 1’s map margin. Positive settles as a win, negative as a loss, zero as a push. Checked against \/v4\/settlements<\/code> on two played best-of-threes, that rule matched the feed on all fifteen rungs both times.<\/p>\n
Which bookmakers price Counter-Strike 2 the tightest?<\/h3>\n
Across 14 deep boards measured on 10 September 2026, Polymarket ran a 1.00% median margin on the series winner, Kalshi 1.03% and Duel 3.49%, against a 6.46% board median over 63 books. Polymarket and Kalshi appeared on all 14 fixtures.<\/p>\n
How much CS2 history can I pull on the free tier?<\/h3>\n
Every recorded snapshot. On one FISSURE Playground series, Pinnacle history opened eleven hours before the first map and held 36 pre-match active snapshots on the favourite with 30 price changes. Request up to three bookmakers per call.<\/p>\n