One API for live odds from 450+ bookmakers

What is Odds-API.io? (sports odds API overview)

Odds-API.io is a developer odds feed: it collects publicly displayed odds from 450+ bookmakers, matches events, teams and markets across them, and serves one JSON format over REST and WebSocket.

• For books with no public API (Bet365, for example) it is a reliable way to get their lines programmatically.
• The same match returns the same event id and market names at every bookmaker, so prices compare directly.
• Beyond raw odds it ships ready-made value bets, arbitrage, dropping odds, closing lines and bet grading.

For background, see the official sports betting API overview and what an odds API is. Books without a public API, such as Bet365, are the classic case: the Bet365 odds API integration is how most developers get those lines.

Coverage: Bet365, DraftKings and 450+ bookmakers, sports and regions

34 sports, 12,000+ leagues and 450+ bookmakers including exchanges and prediction markets; most books are covered pre-match and live.

Major bookmakers (from each book's page on odds-api.io)

Counts as shown on odds-api.io on 2026-11-02; they change over time. The 29 Oct 2026 changelog says all 48 ADM-licensed Italian sportsbooks are covered. https://odds-api.io/sportsbooks

34 sports

Browse bookmakers by region

By bookmaker: DraftKings odds and player props in Python, Betfair Exchange back, lay and depth prices, SBOBET odds API. By sport: the football odds API.

Live odds API: WebSocket streaming

WebSocket is the recommended way to get odds: connect to wss://api.odds-api.io/v3/ws, subscribe by market, and receive odds, scores and status on one connection. It is a paid add-on (2× the plan price in total).

• Required: markets (e.g. ML,Spread,Totals); optional channels=odds,scores,status.
• Filters: sport (max 10), leagues (max 20), eventIds (max 50), status=live or prematch.
• Reconnect with lastSeq to replay missed messages (24-hour retention); replayComplete=true adds an end-of-replay marker.
• Up to 2 connections per key; the client must support permessage-deflate or it gets HTTP 426.
• Message types: welcome, created, updated, deleted, no_markets, score, status, resync_required. An updated message replaces that book's markets for the event; do not merge.

// npm i ws   (permessage-deflate is on by default in ws)
import WebSocket from "ws";
let lastSeq;
function connect() {
  const q = new URLSearchParams({ apiKey: process.env.ODDS_API_KEY,
    markets: "ML,Spread,Totals", sport: "football", status: "live" });
  if (lastSeq) q.set("lastSeq", lastSeq);
  const ws = new WebSocket("wss://api.odds-api.io/v3/ws?" + q);
  ws.on("message", (raw) => {
    const msg = JSON.parse(raw);
    if (msg.seq) lastSeq = msg.seq;
    if (msg.type === "updated") {
      // replace this bookmaker's stored markets for the event; do not merge
    }
  });
  ws.on("close", () => setTimeout(connect, 2000));
}
connect();

https://docs.odds-api.io/guides/websockets

Live odds API: polling vs WebSocket compares the three refresh strategies. In-play betting odds are the most latency-sensitive; the WebSocket live odds stream tutorial has complete code.

Worked examples: arbitrage betting, value bets, closing line odds and odds comparison (with code)

All four examples use only endpoints and fields from the official docs. Replace YOUR_API_KEY with your own key and keep it in an environment variable.

import os, requests
r = requests.get("https://api.odds-api.io/v3/arbitrage-bets", params={
    "apiKey": os.environ["ODDS_API_KEY"],
    "bookmakers": "Bet365,SingBet,Unibet",
    "sport": "football", "minProfit": 1, "includeEventDetails": "true"})
r.raise_for_status()
for arb in r.json()[:10]:
    ev = arb.get("event", {})
    print(f'{arb["profitMargin"]:.2f}%  {ev.get("home")} v {ev.get("away")}  {arb["market"]["name"]}')
    for s in arb["optimalStakes"]:      # split of totalStake (1000); scale to your bankroll
        print(f'   {s["bookmaker"]:<10} {s["side"]:<5} stake {s["stake"]:.2f} -> {s["potentialReturn"]:.2f}')

import os, requests
bets = requests.get("https://api.odds-api.io/v3/value-bets", params={
    "apiKey": os.environ["ODDS_API_KEY"], "bookmaker": "Bet365",
    "sport": "football", "includeEventDetails": "true"}).json()
top = sorted((b for b in bets if b["expectedValue"] >= 0.03),
             key=lambda b: b["expectedValue"], reverse=True)[:10]
for b in top:
    side = b["betSide"]
    print(f'EV {b["expectedValue"]*100:.1f}%  {b["event"]["home"]} v {b["event"]["away"]}'
          f'  {b["market"]["name"]} {side} @ {b["bookmakerOdds"][side]}')

import os, requests, statistics
r = requests.get("https://api.odds-api.io/v3/historical/closing-lines", params={
    "apiKey": os.environ["ODDS_API_KEY"], "sport": "football",
    "leagues": "england-premier-league",
    "from": "2026-01-01T00:00:00Z", "to": "2026-05-31T23:59:59Z",
    "markets": "ML", "bookmakers": "Bet365,Unibet", "limit": 100})
margins = {}
for ev in r.json():                      # each item is shaped like /historical/odds
    for book, markets in ev.get("bookmakers", {}).items():
        ml = next((m for m in markets if m["name"] == "ML"), None)
        if not ml: continue
        o = ml["odds"][0]
        overround = sum(1 / float(o[k]) for k in ("home", "draw", "away")) - 1
        margins.setdefault(book, []).append(overround)
for book, xs in margins.items():
    print(f"{book}: {len(xs)} matches, average closing margin {statistics.mean(xs)*100:.2f}%")
# page through with skip=100, 200, ... for more events

curl -s --compressed "https://api.odds-api.io/v3/odds/summary?apiKey=$ODDS_API_KEY&eventId=123456&markets=ML,Totals"
# per line: best / average / median / worst price and a de-vigged "fair" price

Further reading: what arbitrage betting is, the arbitrage calculator, build an arbitrage bot in Python, the value bets API and closing line value tutorial and Bet365 historical odds and closing lines.

Pricing (checked 2026-11-02)

The four plans differ only in bookmaker count; all include 5,000 requests/hour, every sport and market, pre-match and live. Annual billing costs 10× the monthly price.

https://odds-api.io/pricing

New free keys are paused; see the official free odds API page and the free odds API in 2026 explainer. The official pricing page linked above is authoritative for current plans.

Glossary

Fourteen terms you meet when working with odds data.

Decimal odds

Total return per 1 unit staked, stake included. odds-api.io returns decimal prices as strings, e.g. "2.10".

Implied probability

1 ÷ decimal odds. 2.00 means 50%.

Overround (vig)

How far the implied probabilities of all outcomes exceed 100%: the bookmaker's margin.

De-vig / fair price

Scaling implied probabilities so they sum to 100%. The fair field in /odds/summary uses the median de-vigged probability.

Expected value (EV)

Docs definition: EV = probability × odds − 1; positive EV marks a value bet.

Arbitrage (surebet)

When the best prices across books imply a total under 100%, so a stake split locks in a return; impliedProbability < 1 in /arbitrage-bets.

Closing line

The last price before kick-off, often treated as the most efficient market price.

Closing line value (CLV)

The gap between your price and the closing price; a measure of whether you beat the market.

Sharp book

A high-limit book that leads price discovery; a soft book is the opposite.

Exchange

A venue where users back and lay against each other (e.g. Betfair Exchange) and the venue charges commission.

Dropping odds

A fast price fall, often money or information arriving; /dropping-odds measures drops since opening, 12h, 24h and 48h.

Asian handicap

A handicap without the draw, including quarter lines; in odds-api.io it lives under the Spread market.

Player props

Markets on one player's output such as shots, assists or points.

In-play / live

Markets priced during the match; prices move fast, so WebSocket suits them.

More terms and tools: implied probability, value betting, Asian handicap API guide, the odds converter and the bookmaker margin calculator.

Popular topics

Common searches, grouped: the first two groups jump to the matching section on this page; the last goes to official odds-api.io pages.