DEV Community: Markus

Backtest a Betting Model in Python with Closing Odds

Markus — Thu, 12 Nov 2026 11:46:00 +0000

Most betting models look good on the data they were built on. The test is how their picks compare with the closing market on matches the model has not seen. This guide backtests a small Elo model for the Premier League in Python against historical closing odds from the Odds-API.io v3 API. It reports three numbers for every strategy: hit rate, return on a 1 unit stake, and closing line value (CLV).

The script was run against the live API on 12 November 2026, and the output below is from that run. It covers 821 Premier League matches from September 2024 to October 2026. Ten bookmakers were requested, and 316 matches since December 2025 have closing odds from at least five of them.

If you want the live side of this, logging the price you take and grading it against the close later, read Value Bets API: Track Closing Line Value in Python. For pulling closing odds into pandas without a model, see Oddsportal API Alternative: Football Odds History in Python.

What you need

Python 3.8 or newer and the official SDK: pip install odds-api-io.
An API key on a paid plan, set as ODDS_API_KEY. The bulk /v3/historical/closing-lines endpoint is paid. The per-event historical endpoints work on every plan.
The bookmakers you request must be selected on your key. Bookmaker names are case-sensitive, so use them exactly as /v3/bookmakers lists them.

Step 1: Pull closing lines month by month

/v3/historical/closing-lines returns every settled match in a league and date range, with the final score and each bookmaker's last price before kick-off. One request can span up to 366 days and returns at most 100 matches, so a two-season window needs more than one call either way. The script loops over calendar months and caches each month to a JSON file, in a folder named after the league and bookmaker list. A rerun reads from disk, and when you extend the window only the new months hit the API. If a month was still in progress when you fetched it, delete that month's JSON file. The SDK's iter_closing_lines handles the 100-match pages.

Premier League closing odds in the archive start in December 2025, and results go back to September 2024. Matches before December come back with scores and an empty bookmakers object. That is useful here: the Elo ratings warm up on 15 months of results before the first bet.

Step 2: Build a fair closing price

A single bookmaker's close includes its margin. To get a fair price, the script takes every book with a full home, draw and away close, removes the margin from each one by scaling the implied probabilities to sum to 1, and averages the result. Matches need at least five books to count, and most of the 316 have seven to nine.

Before that it drops bad rows. In a few December 2025 matches one book's close sat far from every other book. In one, two books closed an away side at 7.00 while the other seven priced it between 1.53 and 1.60. Any book with a price more than 20% from the median for that outcome is removed from the match. Some removed prices may have been real, but a few bad ones can move an average a long way.

Step 3: The model

The model is a plain Elo rating. Every team starts at 1500, the home side gets 60 rating points, and ratings move by up to 20 points after each result. Sides promoted for 2025/26 and 2026/27 start at the average of the three lowest-rated sides from the season before, roughly where the relegated sides finished. Elo gives an expected score, so the script takes the draw rate seen so far and subtracts half of it to get a win probability for each side.

The betting rule: for each match from 8 December 2025, take the best closing price across the ten books for home and away. Pick the side where the model's probability times that price is higher. If that number is above 1.05, record a 1 unit bet on it. That is at most one bet per match. As a control, the script also backs every home side at the best price.

The script predicts every match on a date before it applies any result from that date, so no prediction uses a result from the same day. K, the home bonus and the 5% threshold were set before the first run and not changed to improve these results.

The script

import hashlib
import json
import math
import os
import statistics
from datetime import date
from itertools import groupby
from pathlib import Path

from odds_api import OddsAPIClient

LEAGUE = "england-premier-league"
BOOKS = ["Bet365", "Unibet", "William Hill", "Bwin", "888Sport",
         "Paddy Power", "Ladbrokes", "Betway", "SingBet", "Sbobet"]
FIRST_MONTH, LAST_MONTH = date(2024, 9, 1), date(2026, 10, 1)
BET_FROM = "2025-12-08"
MIN_BOOKS = 5
MIN_EDGE = 0.05
MAX_GAP = 0.20
K, HOME_ADV = 20, 60
MARKETS = ["ML"]
SIDES = ("home", "draw", "away")
CACHE = Path("cache") / hashlib.sha1(json.dumps([LEAGUE, MARKETS, BOOKS]).encode()).hexdigest()[:10]


def month_windows(first, last):
    d = first
    while d <= last:
        nxt = date(d.year + d.month // 12, d.month % 12 + 1, 1)
        yield f"{d}T00:00:00Z", f"{date.fromordinal(nxt.toordinal() - 1)}T23:59:59Z"
        d = nxt


def fetch_month(client, start, end):
    path = CACHE / f"{start[:7]}.json"
    if path.exists():
        return json.loads(path.read_text())
    rows = list(client.iter_closing_lines(
        sport="football", leagues=[LEAGUE], from_=start, to=end,
        markets=MARKETS, bookmakers=BOOKS))
    CACHE.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(rows))
    return rows


def final_score(event):
    scores = event.get("scores") or {}
    home, away = scores.get("home"), scores.get("away")
    if isinstance(home, (int, float)) and isinstance(away, (int, float)):
        return home, away
    return None


def closing_prices(event):
    prices = {}
    for book, markets in (event.get("bookmakers") or {}).items():
        for m in markets:
            if m.get("name") == "ML" and m.get("odds"):
                try:
                    p = {s: float(m["odds"][0][s]) for s in SIDES}
                except (KeyError, TypeError, ValueError):
                    continue
                if all(math.isfinite(v) and v > 1 for v in p.values()):
                    prices[book] = p
    return drop_outliers(prices)


def drop_outliers(prices):
    if len(prices) < 3:
        return prices
    median = {s: statistics.median(p[s] for p in prices.values()) for s in SIDES}
    return {b: p for b, p in prices.items()
            if all(abs(p[s] / median[s] - 1) <= MAX_GAP for s in SIDES)}


def fair_probs(prices):
    devigged = []
    for p in prices.values():
        total = sum(1 / p[s] for s in SIDES)
        devigged.append({s: (1 / p[s]) / total for s in SIDES})
    return {s: sum(d[s] for d in devigged) / len(devigged) for s in SIDES}


def season_of(kickoff):
    year, month = int(kickoff[:4]), int(kickoff[5:7])
    return year if month >= 7 else year - 1


def elo_expected(r_home, r_away):
    return 1 / (1 + 10 ** ((r_away - r_home - HOME_ADV) / 400))


def summarise(name, bets):
    n = len(bets)
    print(f"\n{name}")
    if n < 2:
        print(f"  {n} bets, too few to summarise")
        return
    pnl = [b["odds"] - 1 if b["won"] else -1 for b in bets]
    roi = sum(pnl) / n
    half = 1.96 * statistics.stdev(pnl) / math.sqrt(n)
    clv = [b["odds"] / b["fair_odds"] - 1 for b in bets]
    wins = sum(b["won"] for b in bets)
    print(f"  bets {n}, won {wins} ({wins / n:.1%}), market expected {sum(1 / b['fair_odds'] for b in bets):.1f} wins")
    print(f"  average entry odds {sum(b['odds'] for b in bets) / n:.2f}")
    print(f"  return per 1 unit at best close {roi:+.1%} (approx. 95% range {roi - half:+.1%} to {roi + half:+.1%})")
    b365 = [b for b in bets if b["b365"]]
    if b365:
        roi_b365 = sum(b["b365"] - 1 if b["won"] else -1 for b in b365) / len(b365)
        print(f"  return per 1 unit at Bet365 close {roi_b365:+.1%} ({len(b365)} bets)")
    if "edge" in bets[0]:
        print(f"  edge the model claimed: average {sum(b['edge'] for b in bets) / n:+.1%}")
    print(f"  CLV vs fair close: average {statistics.mean(clv):+.2%} (approx. 95% range"
          f" {statistics.mean(clv) - 1.96 * statistics.stdev(clv) / math.sqrt(n):+.2%} to"
          f" {statistics.mean(clv) + 1.96 * statistics.stdev(clv) / math.sqrt(n):+.2%}),"
          f" positive on {sum(c > 0 for c in clv) / n:.0%} of bets")


def main():
    client = OddsAPIClient(api_key=os.environ["ODDS_API_KEY"])
    events = []
    for start, end in month_windows(FIRST_MONTH, LAST_MONTH):
        events += fetch_month(client, start, end)
    events = sorted((e for e in events if final_score(e)), key=lambda e: e["date"])

    if not events:
        print("no settled matches with scores")
        return
    ratings, results, newcomer_base, teams_by_season = {}, [], {}, {}
    model_bets, home_bets, priced = [], [], 0

    for _, day in groupby(events, key=lambda e: e["date"][:10]):
        day = list(day)
        draw_rate = results.count(0.5) / len(results) if results else 0.25
        for e in day:
            season = season_of(e["date"])
            if season not in newcomer_base and season - 1 in teams_by_season:
                previous = sorted(ratings[t] for t in teams_by_season[season - 1])
                newcomer_base[season] = statistics.mean(previous[:3])
            for team in (e["home"], e["away"]):
                if team not in ratings:
                    ratings[team] = newcomer_base.get(season, 1500)
                teams_by_season.setdefault(season, set()).add(team)

        updates = []
        for e in day:
            exp_home = elo_expected(ratings[e["home"]], ratings[e["away"]])
            hs, as_ = final_score(e)
            outcome = "home" if hs > as_ else "away" if as_ > hs else "draw"
            updates.append((e, exp_home, outcome))

            prices = closing_prices(e)
            if e["date"] < BET_FROM or len(prices) < MIN_BOOKS:
                continue
            priced += 1
            clamped = min(max(exp_home, draw_rate / 2), 1 - draw_rate / 2)
            model = {"home": clamped - draw_rate / 2, "away": 1 - clamped - draw_rate / 2}
            fair = fair_probs(prices)
            best = {s: max(p[s] for p in prices.values()) for s in ("home", "away")}

            def bet(side):
                return {"date": e["date"][:10], "match": f"{e['home']} v {e['away']}", "side": side,
                        "odds": best[side], "fair_odds": 1 / fair[side],
                        "b365": prices.get("Bet365", {}).get(side), "won": outcome == side}

            home_bets.append(bet("home"))
            edge = {s: model[s] * best[s] - 1 for s in ("home", "away")}
            side = max(edge, key=edge.get)
            if edge[side] > MIN_EDGE:
                model_bets.append({**bet(side), "edge": edge[side]})

        for e, exp_home, outcome in updates:
            score = {"home": 1, "draw": 0.5, "away": 0}[outcome]
            ratings[e["home"]] += K * (score - exp_home)
            ratings[e["away"]] -= K * (score - exp_home)
            results.append(score)

    print(f"{len(events)} matches, {priced} from {BET_FROM} with closing odds from {MIN_BOOKS}+ books")
    summarise("Elo model, bet when model edge > 5% at the best closing price", model_bets)
    summarise("Baseline, back every home side at the best closing price", home_bets)
    print("\nlast five model bets")
    for b in model_bets[-5:]:
        print(f"  {b['date']}  {b['match']:<40} {b['side']:<4} {b['odds']:.2f} vs fair {b['fair_odds']:.2f}"
              f"  {'won' if b['won'] else 'lost'}")


if __name__ == "__main__":
    main()

Save it as backtest.py, set ODDS_API_KEY and run python3 backtest.py from a folder you can write to. This run used SDK version 1.2.2.

The output

821 matches, 316 from 2025-12-08 with closing odds from 5+ books

Elo model, bet when model edge > 5% at the best closing price
  bets 232, won 61 (26.3%), market expected 70.1 wins
  average entry odds 4.00
  return per 1 unit at best close -16.6% (approx. 95% range -36.9% to +3.7%)
  return per 1 unit at Bet365 close -19.9% (232 bets)
  edge the model claimed: average +28.1%
  CLV vs fair close: average -0.90% (approx. 95% range -1.30% to -0.51%), positive on 27% of bets

Baseline, back every home side at the best closing price
  bets 316, won 122 (38.6%), market expected 136.1 wins
  average entry odds 2.80
  return per 1 unit at best close -15.1% (approx. 95% range -29.1% to -1.1%)
  return per 1 unit at Bet365 close -17.7% (316 bets)
  CLV vs fair close: average -2.33% (approx. 95% range -2.60% to -2.06%), positive on 13% of bets

last five model bets
  2026-10-31  Coventry City v Sunderland AFC           home 3.25 vs fair 3.16  won
  2026-10-31  Hull City v Ipswich Town                 home 3.00 vs fair 3.09  lost
  2026-10-31  Manchester City v Brighton & Hove Albion home 1.73 vs fair 1.80  lost
  2026-10-31  Tottenham Hotspur v Crystal Palace       away 5.10 vs fair 5.23  lost
  2026-10-31  Aston Villa v Fulham FC                  home 2.01 vs fair 2.08  lost

Reading the results

The model claimed an average edge of 28.1% on its 232 bets. The results say it lost 16.6% per unit staked. CLV says the prices it took were 0.90% worse than the fair close on average.

If the closing market is right about the probabilities, the expected return of a bet at price P is P divided by the fair closing price, minus one. That is the CLV. So the closing market expected these 232 bets to return about -1%. The model expected +28.1%. The results came in at -16.6%, with 61 winners where the market expected 70.1.

The approximate 95% range on the result runs from -36.9% to +3.7%. That is too wide to tell a -1% strategy from a -15% one. The home-side baseline shows the same thing. It had CLV of -2.33% and returned -15.1%, with 122 home wins where the market expected 136.1.

A gap that large between the model's estimate and the market's points to a badly calibrated model. A naive Elo disagrees with the market on most matches, mostly by liking outsiders more than the books do. 216 of its 232 bets were on sides with a fair closing price above 2.00, and the average entry price was 4.00.

Why CLV matters more than short-run results

On the model's bets, the return per 1 unit bet had a standard deviation of about 1.6 units. Narrowing the 95% range on the return to plus or minus 2% would take about 24,000 bets like these, assuming each bet is independent.

CLV does not depend on who scored. Per bet it had a standard deviation of about 3%, against 158% for the return. On the same 232 bets, its 95% range is -1.30% to -0.51%, narrow enough to say the prices were worse than the fair close. That is the reason to track it. It still depends on the fair price being a good estimate, and on the sample being more than a few dozen bets.

Caveats

Entry price. The archive stores closing prices, so this backtest assumes you bet at the close at the best of ten books. CLV here measures the gap between the best close and the average fair close. In live use you bet earlier and log the price you took, then compare it with the close in the same way.
Which close. The fair price here is an average of five to ten books after margin removal. Grading against one book's close gives different numbers. Betting at the Bet365 close alone turned -16.6% into -19.9%, because the Bet365 prices on the same picks paid less than the best of ten.
Margin removal. Scaling probabilities proportionally is the simplest method. It shrinks every implied probability by the same factor, while books tend to put more of their margin on outsiders. On a strategy that backs outsiders, a different method would move the fair prices and the CLV.
Sample size. 316 matches in one league is a small test. The closing-lines endpoint takes up to 10 leagues per request, so adding leagues is the simplest way to get more bets.
Data cleaning. Check the extremes before trusting any average. Before the outlier filter, a handful of bad December prices pushed the model's average CLV to +3.7%.

Next steps

Swap in your own model inside the loop. It needs a probability for home and away before each match, and the evaluation stays the same. For goals models, add Totals to the markets list and write the over and under probability and settlement for each line. For a bigger sample, run more league slugs from /v3/leagues?sport=football, one league at a time or with ratings and draw rates kept per league. The historical odds guide lists every parameter and limit, and the SDK guide covers the Python and Node.js clients.

I run Odds-API.io, so I'm biased toward the API used here. Originally published on the Odds-API.io blog.

Live Odds API in Node.js: Build a WebSocket Odds Tracker

Markus — Thu, 12 Nov 2026 11:19:35 +0000

This guide builds a small Node.js script that follows in-play odds for one football league over a WebSocket. It keeps the latest match-winner price from every bookmaker in memory, prints a line whenever the best price for home, draw or away changes, and after a disconnect it resumes from where it stopped, so the table stays current.

It is about 230 lines and uses the official Node.js SDK plus ws. If you are still deciding between polling and streaming, read Live Odds API: Polling vs WebSocket Streaming first. For the same ideas in Python, see the client in Odds Feed API: How It Works and How to Pick a Provider.

What the tracker does

Lists the live matches in the league over REST.
Takes a REST snapshot of their odds, together with the stream position that snapshot matches.
Opens the WebSocket from that position, filtered to one league, live matches only and one market.
Replaces the stored prices for a match and bookmaker on every update, and prints the best price per outcome when it moves.
Reconnects from the last sequence number after a drop, and rebuilds from REST if the server says it cannot replay the gap.

Here is output from a test run on 12 November 2026, following the live club friendlies (node tracker.mjs club-friendlies) on a key with eight bookmakers selected, Polymarket among them. The disconnect at 10:31:54 was forced to test the resume:

10:30:44  FK Iskra v Mladost Donja Gorica  home none -> 4.76 Polymarket  draw none -> 5.56 Polymarket  away none -> 1.32 Polymarket
10:30:44  RB Leipzig v Mlada Boleslav  home none -> 1.53 Bet365  draw none -> 5.30 Unibet  away none -> 8.00 Unibet
10:30:44  snapshot: 2 live events, 2 with ML prices, seq 2874836490
10:30:44  connected, 8 bookmakers on this key
10:30:44  caught up (replayed), seq 2874836509
10:31:15  RB Leipzig v Mlada Boleslav  draw 5.30 Unibet -> 5.25 Unibet  away 8.00 Unibet -> 7.50 Unibet
10:31:17  RB Leipzig v Mlada Boleslav  home 1.53 Bet365 -> 1.55 DraftKings
10:31:35  FK Iskra v Mladost Donja Gorica  no ML prices left
10:31:40  FK Iskra v Mladost Donja Gorica  home none -> 5.00 Polymarket  draw none -> 5.26 Polymarket  away none -> 1.51 Polymarket
10:31:54  disconnected, reconnecting in 1124 ms from seq 2874865192
10:31:55  connected, 8 bookmakers on this key
10:31:55  caught up (replayed), seq 2874866858
10:32:11  RB Leipzig v Mlada Boleslav  home 1.55 DraftKings -> 1.57 Bet365
10:32:13  RB Leipzig v Mlada Boleslav  away 7.50 Unibet -> 8.00 Unibet

The "no ML prices left" line is a suspension: the only bookmaker pricing that match pulled its match-winner market for a few seconds, and the next update brought it back.

Prerequisites

Node.js 20 or later.
An Odds-API.io key on a paid plan with the WebSocket add-on. The add-on is listed on the pricing page.
The bookmakers you want selected on the key. The stream has no bookmaker parameter. It sends updates for every bookmaker selected on your account, so the selection is your bookmaker filter. Change it in the dashboard or with client.selectBookmakers(['Bet365', 'Unibet']). Write the names as the sportsbooks list does. The REST odds endpoints are case-sensitive and reject bet365 with a 400.

Install the SDK and ws:

npm install odds-api-io ws

The server only accepts connections that negotiate permessage-deflate compression, and refuses the rest with HTTP 426. ws negotiates it by default, and the SDK uses it when it is installed. Without ws the SDK falls back to the WebSocket built into Node, which also negotiated compression in our tests on Node 20, 22, 24 and 26, but ws is still worth installing: when the server refuses a connection, the SDK can only tell you why (bad key, bad filter, no WebSocket access) if ws is installed.

The code

Save this as tracker.mjs and run ODDS_API_KEY=your_key node tracker.mjs. Pass a league slug as the first argument to follow a different league, for example node tracker.mjs spain-laliga.

// Live odds tracker: best match-winner price per outcome for one league, over WebSocket.
// npm install odds-api-io ws
// ODDS_API_KEY=... node tracker.mjs [league-slug]
import { OddsAPIClient, OddsWebSocket } from 'odds-api-io';

const apiKey = process.env.ODDS_API_KEY;
if (!apiKey) {
  console.error('Set ODDS_API_KEY first.');
  process.exit(1);
}

const SPORT = 'football';
const LEAGUE = process.argv[2] ?? 'england-premier-league';
const MARKET = 'ML';
const OUTCOMES = ['home', 'draw', 'away'];

const client = new OddsAPIClient({ apiKey });

let prices = new Map(); // eventId -> Map(bookmaker -> { home, draw, away })
const best = new Map(); // eventId -> { home: { price, bookie }, ... }
const names = new Map(); // eventId -> "Home v Away"
let touched = new Set(); // "eventId:bookmaker" pairs seen since the last welcome
let feed;
let resyncing = false;

const log = (text) => console.log(`${new Date().toISOString().slice(11, 19)}  ${text}`);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

function chunk(list, size) {
  const out = [];
  for (let i = 0; i < list.length; i += size) out.push(list.slice(i, i + size));
  return out;
}

function readPrices(markets) {
  const line = markets.find((m) => m.name === MARKET)?.odds?.[0];
  if (!line) return null;
  const out = {};
  for (const outcome of OUTCOMES) {
    const price = Number.parseFloat(line[outcome]);
    if (price > 1) out[outcome] = price;
  }
  return Object.keys(out).length ? out : null;
}

function eventName(id) {
  if (!names.has(id)) {
    names.set(id, `event ${id}`);
    client
      .getEventById(id)
      .then((e) => names.set(id, `${e.home} v ${e.away}`))
      .catch(() => {});
  }
  return names.get(id);
}

function fmt(entry) {
  return entry ? `${entry.price.toFixed(2)} ${entry.bookie}` : 'none';
}

function refreshBest(id) {
  const books = prices.get(id);
  const prev = best.get(id) ?? {};
  const next = {};
  for (const outcome of OUTCOMES) {
    for (const [bookie, p] of books ?? []) {
      const price = p[outcome];
      if (!price) continue;
      const current = next[outcome];
      if (!current || price > current.price || (price === current.price && bookie === prev[outcome]?.bookie)) {
        next[outcome] = { price, bookie };
      }
    }
  }

  const changes = OUTCOMES.filter(
    (o) => prev[o]?.price !== next[o]?.price || prev[o]?.bookie !== next[o]?.bookie
  ).map((o) => `${o} ${fmt(prev[o])} -> ${fmt(next[o])}`);

  if (books?.size) {
    if (changes.length) log(`${eventName(id)}  ${changes.join('  ')}`);
    best.set(id, next);
  } else {
    if (best.has(id)) log(`${eventName(id)}  no ${MARKET} prices left`);
    prices.delete(id);
    best.delete(id);
  }
}

// Every odds message carries the full market set for the pair: replace, never merge.
function apply(eventId, bookie, markets) {
  const id = String(eventId);
  touched.add(`${id}:${bookie}`);
  const latest = readPrices(markets);
  let books = prices.get(id);
  if (latest) {
    if (!books) prices.set(id, (books = new Map()));
    books.set(bookie, latest);
  } else {
    books?.delete(bookie);
  }
  refreshBest(id);
}

// After a state snapshot, pairs the server did not resend are gone.
function dropUntouched() {
  for (const [id, books] of prices) {
    for (const bookie of books.keys()) {
      if (!touched.has(`${id}:${bookie}`)) books.delete(bookie);
    }
    refreshBest(id);
  }
}

// REST snapshot of every live event in the league, plus the stream position it matches.
async function loadSnapshot() {
  const events = await client.getEvents({ sport: SPORT, league: LEAGUE, status: 'live' });
  for (const e of events) names.set(String(e.id), `${e.home} v ${e.away}`);

  const fresh = new Map();
  let seq = null;
  if (events.length) {
    const { bookmakers } = await client.getSelectedBookmakers();
    for (const eventIds of chunk(events.map((e) => e.id), 10)) {
      for (const books of chunk(bookmakers, 30)) {
        const page = await client.getOddsSnapshot({ eventIds, bookmakers: books, markets: [MARKET] });
        if (page.seq === null) throw new Error('snapshot came back without a seq');
        seq = seq === null ? page.seq : Math.min(seq, page.seq);
        for (const event of page.data) {
          for (const [bookie, markets] of Object.entries(event.bookmakers)) {
            const latest = readPrices(markets);
            if (!latest) continue;
            const id = String(event.id);
            if (!fresh.has(id)) fresh.set(id, new Map());
            fresh.get(id).set(bookie, latest);
          }
        }
      }
    }
  }
  return { fresh, seq, count: events.length };
}

async function rebuild() {
  for (let attempt = 1; ; attempt++) {
    try {
      const { fresh, seq, count } = await loadSnapshot();
      const ids = new Set([...prices.keys(), ...fresh.keys()]);
      prices = fresh;
      for (const id of ids) refreshBest(id);
      log(`snapshot: ${count} live events, ${fresh.size} with ${MARKET} prices, seq ${seq ?? 'none'}`);
      return seq;
    } catch (err) {
      if ([400, 401, 403, 404].includes(err.status)) throw err;
      const delay = Math.min(30_000, 1000 * 2 ** attempt);
      log(`snapshot failed (${err.name}), retrying in ${delay} ms`);
      await sleep(delay);
    }
  }
}

async function resync(reason) {
  if (resyncing) return;
  resyncing = true;
  log(`resync required (${reason}), rebuilding from REST`);
  const old = feed;
  feed = null;
  old.close();
  try {
    await connect(await rebuild());
  } catch (err) {
    log(`stopped: ${err.message}`);
    process.exitCode = 1;
  } finally {
    resyncing = false;
  }
}

function connect(lastSeq) {
  const ws = new OddsWebSocket({
    apiKey,
    markets: [MARKET],
    leagues: [LEAGUE],
    status: 'live',
    lastSeq: lastSeq ?? undefined,
  });
  feed = ws;
  // A closed feed can still deliver queued frames; only the current one may touch state.
  const on = (type, handler) => ws.on(type, (m) => ws === feed && handler(m));

  on('welcome', (m) => {
    touched = new Set();
    log(`connected, ${m.bookmakers.length} bookmakers on this key`);
    if (m.warning) log(`warning: ${m.warning}`);
  });
  on('created', (m) => apply(m.id, m.bookie, m.markets));
  on('updated', (m) => apply(m.id, m.bookie, m.markets));
  on('deleted', (m) => apply(m.id, m.bookie, []));
  on('no_markets', (m) => apply(m.id, m.bookie, []));
  on('replay_complete', (m) => {
    if (m.outcome === 'live' && m.last_seq > 0) return resync('no catch-up sent');
    if (m.outcome !== 'replayed' && m.outcome !== 'snapshot') return;
    if (m.outcome === 'snapshot') dropUntouched();
    // Snapshot messages carry no seq, so move the resume point to where the catch-up ended.
    if (m.through_seq > (ws.lastSeq ?? 0)) ws.lastSeq = m.through_seq;
    log(`caught up (${m.outcome}), seq ${ws.lastSeq}`);
  });
  on('resync_required', (m) => resync(m.reason));
  on('reconnecting', ({ delay, lastSeq: seq }) => log(`disconnected, reconnecting in ${delay} ms from seq ${seq}`));
  on('error', (err) => log(`error: ${err.message}`));
  on('close', ({ willReconnect, code }) => {
    if (willReconnect) return;
    log(`stopped, connection closed (${code})`);
    process.exitCode = 1;
  });

  return ws.connect();
}

process.on('SIGINT', () => {
  log(`stopping at seq ${feed?.lastSeq}`);
  feed?.close();
  process.exit(0);
});

try {
  await connect(await rebuild());
} catch (err) {
  console.error(`Stopped: ${err.message}`);
  process.exit(1);
}

How it works

State: one entry per match and bookmaker

prices maps an event id to a map of bookmaker to { home, draw, away }. The tracker reads the first line of the ML market (match winner) and parses the prices, which arrive as strings.

Every created and updated message carries the complete set of markets for that event and bookmaker, so apply() replaces the entry and never merges into it. A suspended market is not flagged in the feed. It is left out of the next message. If you merge, a price that is no longer offered stays in your data. Here, a message without an ML market removes that bookmaker from the match, and deleted and no_markets do the same, since they always arrive with an empty markets array.

Start from a REST snapshot

Without a snapshot the table is empty until each bookmaker sends its next update. loadSnapshot() fills it first. It lists live events with getEvents(), then calls getOddsSnapshot(), which is /odds/multi with includeSeq=true. That endpoint takes up to 10 events and 30 bookmakers per request, so the script loops over both. Each response carries the X-OddsAPI-Seq header, the position in the stream the snapshot matches. The script keeps the lowest one and connects with it as lastSeq. The server then replays anything that changed after the snapshot, so nothing falls between the REST call and the first live message.

The WebSocket messages carry an event id and a bookmaker, not team names. Names come from the getEvents() call, and for a match that goes live after startup the script fetches it once with getEventById().

Filters keep the payload small

The connection asks for leagues: [LEAGUE], status: 'live' and markets: ['ML']. markets is required for the odds channel. Each updated message holds every subscribed market for the pair, so subscribing to ten markets when you print one makes every message bigger. The limits per connection are 40 markets, 10 sports, 20 leagues or 50 event ids, and leagues and eventIds cannot be combined. A key can hold two connections at once. Opening a third closes the oldest one with close code 1008, and the SDK treats that as final instead of reconnecting, so two copies of the tracker plus a test script on one key will knock the first copy off.

To follow totals or handicaps as well, add Totals or Spread to the market list and extend readPrices(). Those markets carry several lines, each with its own hdp, so key the stored prices by line.

Reconnects and replay

Live odds updates carry a seq, a global number that never goes down on your connection. Values are not consecutive, and one update sent for several bookmakers shares a seq. The SDK tracks the highest one it has seen. Rarely, an update arrives without a seq. Apply it as normal; the SDK leaves its position unchanged. When the socket drops, it reconnects with exponential backoff and passes that value as lastSeq. The server replays what you missed, compacted to the latest state per event and bookmaker, and then continues live. Replay data is kept for up to 24 hours.

The SDK also asks for a replay_complete message, which tells you how the catch-up went:

replayed: you got the latest state of everything that changed while you were away.
snapshot: the gap was too large to replay, so the server sent the current state of your subscription as created messages. Any pair it did not resend is gone. The script records every pair it sees after the welcome message and drops the others in dropUntouched().
resync_required: the server could not send a complete state.
live: no catch-up was sent. That is normal on a first connection without lastSeq. On a reconnect it means the server pushed current state to this key a short while ago and skipped it this time, so your table may be missing updates. The script treats it like resync_required.

The created messages in a snapshot catch-up carry no seq, and replay_complete arrives after the last of them. Its through_seq field is where the catch-up ended, so the script moves its resume point there.

A resync_required message comes with a reason, for example snapshot_truncated, replay_limit_exceeded or snapshot_cooldown. The script closes the connection, rebuilds the whole table from REST, and connects again from the new snapshot's sequence number. Do not take the current_seq from that message and resume from it. The updates between your old position and that number would be lost.

A rejected key, a key without WebSocket access, a bad filter, an unknown league or a connection replaced by a newer one stops the script with the reason and exit code 1. The SDK does not retry those.

One detail in connect(): after close(), frames that were already queued can still arrive on the old connection. The on() wrapper ignores events from any connection that is no longer the current one, so a resync cannot be overwritten by a late update.

What to build next

REST fallback. Keep the snapshot code. It is your recovery path, and it works as a fallback when the stream is down. /odds/multi serves the same market format inside an event response. The Fetching Odds guide covers the REST side.

Store the data. Write to Postgres or Redis wherever prices changes: updates and removals in apply(), removals in dropUntouched(), and the full table after rebuild(). Use one row per event, bookmaker and outcome. If the stored board and the seq are saved together, a restarted process can resume from that seq. Otherwise rebuild from REST on restart.

Scores and status. Add channels: ['odds', 'scores', 'status'] to the options to get score changes and match status on the same connection. Keep odds in the list, because channels is an allowlist. Score and status messages have no seq and are not replayed.

Ask questions in plain language. The Odds-API.io MCP server connects the same data to Claude, Cursor and other AI tools, which is useful for checking what the tracker prints against what the API holds.

The WebSocket guide and the WebSocket API reference list every message type, filter and resync reason.

I run Odds-API.io, so I'm biased toward the API used here. Originally published on the Odds-API.io blog.

Comparing Polymarket prices with bookmaker odds in Python

Markus — Thu, 12 Nov 2026 10:57:19 +0000

Prediction markets and sportsbooks price the same games, but they rarely agree exactly. Polymarket might have a team at 62 cents while the bookmakers imply 58%. Whether that gap means something depends on what you're doing with it, but you can't look at it without both prices side by side.

This post pulls both for one match and lines them up as implied probabilities. It uses the Odds-API.io Python SDK, which returns Polymarket and Kalshi prices in the same format as regular bookmakers. You need an API key (paid plans).

Setup

pip install odds-api-io

from odds_api import OddsAPIClient

client = OddsAPIClient(api_key="YOUR_API_KEY")

Find a match

events = client.get_events(sport="football", league="england-premier-league", status="pending")
event = events[0]
print(event["id"], event["home"], "vs", event["away"], event["date"])

Get odds from both worlds

books = "Polymarket,Kalshi,Bet365,Unibet,DraftKings,Betfair Exchange"
odds = client.get_event_odds(event_id=event["id"], bookmakers=books)

Polymarket and Kalshi count toward your plan's bookmaker limit like any other source, and names are case-sensitive (bet365 gets a 400). Every source comes back under odds["bookmakers"], keyed by name, each with a list of markets. For a football match, the ML market has home, draw and away as decimal odds. Prices arrive as strings. For Polymarket and Kalshi the API converts cents to decimal odds, so 60 cents comes back as 1.67.

Turn odds into probabilities

Decimal odds of 2.00 imply 50%. Bookmaker prices include a margin, so the three outcomes add up to more than 100%. Normalising removes it:

def implied(ml):
    raw = {k: 1 / float(ml[k]) for k in ("home", "draw", "away") if ml.get(k)}
    total = sum(raw.values())
    return {k: v / total for k, v in raw.items()}

rows = {}
for book in books.split(","):
    markets = odds["bookmakers"].get(book, [])
    ml = next((m for m in markets if m["name"] == "ML"), None)
    if ml and ml["odds"]:
        rows[book] = implied(ml["odds"][0])

Compare

sportsbooks = [b for b in rows if b not in ("Polymarket", "Kalshi", "Betfair Exchange")]
consensus = {
    k: sum(rows[b][k] for b in sportsbooks) / len(sportsbooks)
    for k in ("home", "draw", "away")
}

print(f"{'source':<18}{'home':>8}{'draw':>8}{'away':>8}")
for book, p in rows.items():
    print(f"{book:<18}" + "".join(f"{p.get(k, 0):>8.1%}" for k in ("home", "draw", "away")))
print(f"{'consensus':<18}" + "".join(f"{consensus[k]:>8.1%}" for k in ("home", "draw", "away")))

Betfair Exchange is an exchange rather than a bookmaker, so it stays in the table but out of the bookmaker average. Here is the output for Manchester City vs Fulham (Premier League, 21 November 2026), run on 12 November:

72221406 Manchester City vs Fulham FC 2026-11-21T12:30:00Z
source                home    draw    away
Polymarket           67.3%   18.8%   13.9%
Kalshi               67.6%   18.6%   13.7%
Bet365               65.9%   19.7%   14.4%
Unibet               66.3%   19.5%   14.2%
DraftKings           65.7%   18.9%   15.4%
Betfair Exchange     67.4%   18.6%   14.1%
consensus            66.0%   19.4%   14.7%

Both prediction markets rate City about 1.5 points higher than the bookmaker average, and they sit close to the exchange. Differences of one or two points are normal noise. Bigger gaps usually come from timing (one side moved on news first) or from thin liquidity on the prediction market. For Polymarket and Kalshi the API also returns the other side of the book (layHome, layDraw, layAway) and the size at each price (depthHome, depthDraw, depthAway, plus depthLay...), which tells you how much is available at that price. On this match Kalshi showed 2,377 behind the City price and 16 on the draw, so a thin side can move on very little money.

Where to take it

Run it on a schedule and log the gap over time, then check it against the result.
Swap the REST call for the WebSocket feed if you want updates as prices move.
Use historical closing lines to see whether the prediction market or the bookmakers were closer to the final price.

Docs for the prediction-market fields: https://docs.odds-api.io/guides/prediction-markets

If you want the bigger picture, we ran the same comparison on closing prices for 13,688 games: Polymarket vs Sportsbooks: How Often Do They Disagree?

I run Odds-API.io, so I'm biased toward the API used here.