{"id":2938,"date":"2026-06-01T10:00:00","date_gmt":"2026-06-01T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=2938"},"modified":"2026-05-29T14:29:23","modified_gmt":"2026-05-29T14:29:23","slug":"tennis-elo-model-python","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/tennis-elo-model-python\/","title":{"rendered":"Tennis ELO Model in Python: Beat the Closing Line with Free Historical Odds"},"content":{"rendered":"\n\n

You Don’t Need a Black-Box Tennis Model. You Need a Sharper Benchmark.<\/h2>\n\n

Search “tennis prediction model” and you get two kinds of results: academic ELO papers with no code, and paid “AI tipster” services that won’t show you their math. Neither is useful if you actually want to build and validate<\/em> your own model.<\/p>\n\n

Here’s the thing nobody tells you: the model is the easy part. ELO ratings for tennis are about 40 lines of Python. The hard part is answering one question \u2014 is my model actually better than the market?<\/strong> And to answer that you need the one number that’s almost impossible to get cheaply: the sharp closing line, plus its full price history.<\/p>\n\n

This guide builds a surface-weighted ELO model from scratch, then benchmarks it against Pinnacle’s de-vigged probability and 23 other bookmakers \u2014 all from a single free API call. We’ll use a real match: Lorenzo Musetti vs Holger Rune, French Open Round 4<\/strong>, which had 24 books pricing it live<\/strong>, including Pinnacle, Kalshi, Polymarket and Betfair Exchange.<\/p>\n\n

The Old Way vs OddsPapi<\/h2>\n\n
\n\n \n
Step<\/th>The Old Way<\/th>OddsPapi<\/th><\/tr><\/thead>\n
Match data & results<\/td>Scrape Tennis Abstract \/ Flashscore, parse HTML<\/td>One \/fixtures<\/code> call (sportId 12)<\/td><\/tr>\n
The sharp benchmark<\/td>Pinnacle API is closed to the public<\/td>\/odds<\/code> returns Pinnacle + 23 books<\/td><\/tr>\n
Closing-line history (for CLV)<\/td>Paid add-on, or scrape every 5 min yourself<\/td>\/historical-odds<\/code> \u2014 free tier<\/td><\/tr>\n
De-vig to “true” probability<\/td>Manual, per book<\/td>Same nested JSON across every book<\/td><\/tr>\n
Cost<\/td>$50\u2013300\/mo + scraper maintenance<\/td>Free tier<\/td><\/tr>\n <\/tbody>\n<\/table>\n<\/figure>\n\n

That third row is the killer. A predictive model is only as good as the yardstick you measure it against, and the only honest yardstick in betting is the closing line<\/strong> \u2014 specifically a sharp book’s closing line, de-vigged. Pinnacle moves their price as sharp money comes in; by the time the match starts, their no-vig probability is the most accurate public forecast on the planet. OddsPapi gives you that line and<\/em> its full history for free, so you can compute Closing Line Value (CLV) and actually prove whether your edge is real.<\/p>\n\n

Step 1: Authenticate<\/h2>\n\n

OddsPapi uses an apiKey<\/code> query parameter<\/strong> \u2014 not a header. Every call needs it.<\/p>\n\n

import requests\n\nAPI_KEY = \"YOUR_API_KEY\"\nBASE_URL = \"https:\/\/api.oddspapi.io\/v4\"\n\n# Smoke test\nr = requests.get(f\"{BASE_URL}\/sports\", params={\"apiKey\": API_KEY})\nprint(r.status_code)  # 200\n<\/code><\/pre>\n\n
Step 2: Find Tennis Fixtures<\/h2>\n\n
Tennis is sportId=12<\/code>. Pull a date range (max 10 days apart) and keep the ones that actually have odds.<\/p>\n\n
import time\n\ndef tennis_fixtures(date_from, date_to):\n    r = requests.get(f\"{BASE_URL}\/fixtures\", params={\n        \"apiKey\": API_KEY,\n        \"sportId\": 12,\n        \"from\": date_from,\n        \"to\": date_to,\n    })\n    return [f for f in r.json() if f.get(\"hasOdds\")]\n\nfixtures = tennis_fixtures(\"2026-06-01\", \"2026-06-07\")\nfor f in fixtures[:5]:\n    print(f[\"fixtureId\"], f[\"participant1Name\"], \"v\", f[\"participant2Name\"],\n          \"|\", f[\"tournamentName\"])\n<\/code><\/pre>\n\n
During Roland Garros this returned 100+ singles fixtures. Our target \u2014 Musetti v Rune \u2014 carried 24 bookmakers<\/strong> on the match-winner market.<\/p>\n\n
Step 3: Fetch the Winner Odds<\/h2>\n\n
The tennis match-winner market is marketId 171<\/code><\/strong>. Outcomes are 171<\/code> (player 1) and 172<\/code> (player 2). The live \/odds<\/code> response is deeply nested \u2014 players[\"0\"]<\/code> is a dict<\/strong> holding the current price (the historical endpoint uses a list; don’t mix them up).<\/p>\n\n
WINNER = \"171\"\n\ndef winner_prices(fixture_id):\n    r = requests.get(f\"{BASE_URL}\/odds\", params={\n        \"apiKey\": API_KEY,\n        \"fixtureId\": fixture_id,\n    })\n    books = r.json().get(\"bookmakerOdds\", {})\n    out = {}\n    for slug, data in books.items():\n        market = (data.get(\"markets\") or {}).get(WINNER)\n        if not market:\n            continue\n        oc = market[\"outcomes\"]\n        try:\n            p1 = oc[\"171\"][\"players\"][\"0\"][\"price\"]\n            p2 = oc[\"172\"][\"players\"][\"0\"][\"price\"]\n        except (KeyError, TypeError):\n            continue\n        if p1 and p2:\n            out[slug] = (p1, p2)\n    return out\n\nprices = winner_prices(\"id1003846272365390\")  # Musetti v Rune\nprint(len(prices), \"books\")\nprint(\"Pinnacle:\", prices[\"pinnacle\"])  # (1.473, 2.71)\n<\/code><\/pre>\n\n
Real output for this match (sorted by margin, tightest first):<\/p>\n\n
\n\n  \n    
Book<\/th>Musetti<\/th>Rune<\/th>Margin (vig)<\/th><\/tr><\/thead>\n  
Kalshi<\/td>1.587<\/td>2.632<\/td>1.01%<\/td><\/tr>\n    
Polymarket<\/td>1.55<\/td>2.70<\/td>1.49%<\/td><\/tr>\n    
Betfair Exchange<\/td>1.55<\/td>2.66<\/td>2.14%<\/td><\/tr>\n    
Parimatch \/ Betsson \/ GGBet<\/td>1.50<\/td>2.66<\/td>3.95%<\/td><\/tr>\n    
Pinnacle<\/strong><\/td>1.473<\/strong><\/td>2.71<\/strong><\/td>4.79%<\/strong><\/td><\/tr>\n    
Bet365 \/ Unibet<\/td>1.47<\/td>2.70<\/td>5.05%<\/td><\/tr>\n    
DraftKings \/ BoyleSports<\/td>1.45<\/td>2.70<\/td>5.94%<\/td><\/tr>\n    
Coral \/ Ladbrokes<\/td>1.47<\/td>2.625<\/td>6.18%<\/td><\/tr>\n  <\/tbody>\n<\/table>\n<\/figure>\n\n
Note the pattern OddsPapi exposes that single-book APIs can’t: the prediction markets (Kalshi, Polymarket) and the exchange (Betfair) price tighter than Pinnacle itself<\/strong> \u2014 1\u20132% margin vs Pinnacle’s 4.8%. That matters for your benchmark, and we’ll come back to it.<\/p>\n\n
Step 4: Build the ELO Engine<\/h2>\n\n
ELO is dead simple. Every player has a rating. Before a match, the expected win probability of player A is a logistic function of the rating gap. After the match, both ratings move toward the actual result \u2014 winner gains, loser loses, scaled by K<\/code> and by how surprising the result was.<\/p>\n\n
def expected_score(rating_a, rating_b):\n    \"\"\"Win probability of A given the rating gap.\"\"\"\n    return 1.0 \/ (1.0 + 10 ** ((rating_b - rating_a) \/ 400.0))\n\ndef update(rating_a, rating_b, a_won, k=32):\n    \"\"\"Return updated (rating_a, rating_b) after a single match.\"\"\"\n    exp_a = expected_score(rating_a, rating_b)\n    score_a = 1.0 if a_won else 0.0\n    rating_a += k * (score_a - exp_a)\n    rating_b += k * ((1 - score_a) - (1 - exp_a))\n    return rating_a, rating_b\n<\/code><\/pre>\n\n
Tennis has one wrinkle that makes a generic ELO useless: surface<\/strong>. A clay specialist like Musetti is a different player on clay than on hard court. The fix the research community settled on (Kovalchik, 2016) is to keep a separate rating per surface<\/strong> and blend it with the overall rating. Here’s a compact surface-aware engine that ingests a match history and spits out ratings:<\/p>\n\n
from collections import defaultdict\n\nclass TennisElo:\n    def __init__(self, k=32, base=1500, surface_weight=0.6):\n        self.overall = defaultdict(lambda: base)\n        self.surface = defaultdict(lambda: defaultdict(lambda: base))\n        self.k = k\n        self.sw = surface_weight  # how much surface form counts\n\n    def rating(self, player, surface):\n        # Blend surface-specific and overall rating\n        return self.sw * self.surface[surface][player] + (1 - self.sw) * self.overall[player]\n\n    def predict(self, p1, p2, surface):\n        return expected_score(self.rating(p1, surface), self.rating(p2, surface))\n\n    def add_match(self, winner, loser, surface):\n        # Update the overall ratings\n        ro_w, ro_l = self.overall[winner], self.overall[loser]\n        self.overall[winner], self.overall[loser] = update(ro_w, ro_l, True, self.k)\n        # Update the surface-specific ratings\n        rs_w, rs_l = self.surface[surface][winner], self.surface[surface][loser]\n        self.surface[surface][winner], self.surface[surface][loser] = update(rs_w, rs_l, True, self.k)\n\n# Feed it your match history (winner, loser, surface), oldest first:\nmodel = TennisElo()\nfor m in match_history:          # list of (winner, loser, surface) tuples\n    model.add_match(*m)\n\np_musetti = model.predict(\"Lorenzo Musetti\", \"Holger Rune\", \"clay\")\nprint(f\"ELO win prob Musetti: {p_musetti:.1%}\")\n<\/code><\/pre>\n\n
Where does match_history<\/code> come from? Process a season of completed results \u2014 ATP\/WTA match logs are widely available as CSV, and you backfill ratings by replaying every match chronologically. The surface_weight<\/code> and k<\/code> are the knobs you tune in the backtest (Step 6).<\/p>\n\n
Step 5: De-vig the Market \u2014 Your Ground Truth<\/h2>\n\n
You can’t compare your ELO probability to a raw bookmaker price, because that price includes the bookmaker’s margin (the “vig”). You have to strip it out first. For a two-way market the simplest method is multiplicative normalisation:<\/p>\n\n
def devig_two_way(odds_a, odds_b):\n    \"\"\"Return (fair_prob_a, fair_prob_b) with the margin removed.\"\"\"\n    imp_a, imp_b = 1 \/ odds_a, 1 \/ odds_b\n    overround = imp_a + imp_b\n    return imp_a \/ overround, imp_b \/ overround\n\n# Pinnacle: Musetti 1.473, Rune 2.71\nfair_m, fair_r = devig_two_way(1.473, 2.71)\nprint(f\"Pinnacle fair: Musetti {fair_m:.1%}, Rune {fair_r:.1%}\")\n# -> Pinnacle fair: Musetti 64.8%, Rune 35.2%\n<\/code><\/pre>\n\n
So the sharpest book on earth, with the margin removed, makes Musetti a 64.8%<\/strong> favourite. That’s your benchmark. (For heavy favourites you may prefer the “power” method, which corrects the favourite\u2013longshot bias \u2014 but for a balanced match like this, multiplicative is fine and within a fraction of a percent.)<\/p>\n\n
Step 6: Compare, and Find the Edge<\/h2>\n\n
Now put the two numbers side by side. Suppose your clay-weighted ELO \u2014 after replaying the season \u2014 outputs ratings of roughly 2003 (Musetti)<\/strong> vs 1897 (Rune)<\/strong>. That’s a 106-point gap, which the logistic turns into:<\/p>\n\n
p = expected_score(2003, 1897)\nprint(f\"ELO: {p:.1%}\")   # 64.8%\n<\/code><\/pre>\n\n
Your model and the sharp market land in the same<\/em> place: ~64.8%. That’s actually the most common outcome when you benchmark against Pinnacle \u2014 and it’s a feature, not a disappointment. It tells you the favourite is fairly priced and your model isn’t fooling itself. The edge isn’t in disagreeing with the market on probability. It’s in the price.<\/strong><\/p>\n\n
Your fair probability says Musetti should be 1 \/ 0.648 = 1.543<\/code>. Now scan all 24 books for the best available price on Musetti:<\/p>\n\n
def best_price(prices, side):\n    # side: 0 for player1, 1 for player2\n    return max(prices.items(), key=lambda kv: kv[1][side])\n\nbook, (m, r) = best_price(prices, 0)\nprint(f\"Best Musetti: {book} @ {m}\")   # Best Musetti: kalshi @ 1.587\n\nfair_odds = 1 \/ fair_m            # 1.543\nev = fair_m * 1.587 - 1           # expected value at the best price\nprint(f\"Fair odds {fair_odds:.3f} | EV at 1.587: {ev:+.2%}\")\n# -> Fair odds 1.543 | EV at 1.587: +2.82%\n<\/code><\/pre>\n\n
Kalshi was offering Musetti at 1.587 while the sharp fair price was 1.543.<\/strong> Backing the favourite there is +2.8% EV<\/strong> versus Pinnacle’s de-vigged line \u2014 a clean, model-confirmed value bet that exists purely because a prediction market priced the favourite more generously than the sharp book. Check the other side too: the best Rune price was 1xBet at 2.74, but fair Rune odds are 1 \/ 0.352 = 2.84<\/code>, so even the best dog price is \u22123.5% EV<\/strong>. Pass.<\/p>\n\n
This is the whole workflow in one screen: ELO gives you an independent prior, the de-vigged sharp line tells you the true probability, and line-shopping across 350+ books turns “I think Musetti wins” into a quantified +EV bet.<\/strong> The model’s real job is to stop you taking the \u2212EV side when the price looks<\/em> tempting.<\/p>\n\n
Step 7: Prove It With Closing Line Value<\/h2>\n\n
One worked example proves nothing \u2014 a model is only validated over hundreds of matches. The professional standard is Closing Line Value<\/strong>: did you consistently bet at prices better than the closing (sharpest) line? Beat the close over a big sample and you are, by definition, +EV. OddsPapi’s free \/historical-odds<\/code> endpoint makes this measurable. The shape differs from live odds \u2014 here players[\"0\"]<\/code> is a list<\/strong> of snapshots:<\/p>\n\n
def closing_line(fixture_id, book=\"pinnacle\"):\n    r = requests.get(f\"{BASE_URL}\/historical-odds\", params={\n        \"apiKey\": API_KEY,\n        \"fixtureId\": fixture_id,\n        \"bookmakers\": book,          # max 3 per call\n    })\n    oc = r.json()[\"bookmakers\"][book][\"markets\"][\"171\"][\"outcomes\"]\n    history = oc[\"171\"][\"players\"][\"0\"]   # list of snapshots\n    return [(s[\"createdAt\"], s[\"price\"]) for s in history]\n\nsnaps = closing_line(\"id1003846272365390\")\nprint(\"Open:\", snaps[0], \"| Close:\", snaps[-1])\n# Open: ('2026-05-31T08:58...', 1.485) | Close: (..., 1.473)\n<\/code><\/pre>\n\n
Pinnacle shortened Musetti from 1.485 to 1.473<\/strong> in the hours before the match \u2014 sharp money landed on the Italian. If you’d taken Kalshi’s 1.587 the morning of the match, you beat the close by a wide margin: textbook positive CLV. A real backtest loops this over your whole bet log:<\/p>\n\n
def clv(bet_odds, closing_odds):\n    \"\"\"Positive = you beat the closing line.\"\"\"\n    return bet_odds \/ closing_odds - 1\n\n# Your 1.587 vs Pinnacle close 1.473\nprint(f\"CLV: {clv(1.587, 1.473):+.1%}\")   # CLV: +7.7%\n<\/code><\/pre>\n\n
Run your ELO picks through this over a season. If your average CLV is positive, your model has a real edge and you can size up with confidence. If it’s negative, no staking plan will save you \u2014 and you’ve learned that for the price of zero API calls. To turn a validated edge into bet sizes, pipe the de-vigged probability into a Kelly criterion staking calculator<\/a>.<\/p>\n\n
Why This Matters: The Three Kill Shots<\/h2>\n\n