Matchbook API: Access UK Exchange Odds Without an Account (Python)

The Matchbook API Problem: Real, But Not Open

Matchbook is the other UK-regulated betting exchange — the one that isn’t Betfair. It’s smaller, it’s sharper, and because it runs a much tighter commission structure (1.5% on net winnings vs Betfair’s 2–5% scale), it attracts the kind of high-volume, low-margin traders who care about basis points. If you’re running an arbitrage or value-betting model in the UK market, Matchbook’s prices are data you want.

Getting them directly, though, is a problem. Matchbook publishes an internal API, but access is gated behind a verified account, you need to manage a session token (just like Betfair), and the commercial use terms for redistribution are not developer-friendly. The official path assumes you’re a bettor using the API for your own accounts, not a developer building a tooling layer on top.

If all you want is the price, this is way more overhead than the job needs.

The “Third Option” for Matchbook Odds

OddsPapi aggregates 350+ bookmakers behind one API key, and Matchbook is one of them. You query ?bookmakers=matchbook and get the current Matchbook back/lay prices alongside whichever other books you ask for, all in a single HTTP call.

What Matchbook Actually Is (And Why It’s Underrated)

Matchbook is a peer-to-peer betting exchange licensed in Alderney and operating primarily in the UK and Ireland. Like Betfair, there’s no house — bettors match against each other, and the platform collects commission on the winning side of the trade. Three things make it distinctive:

• 1.5% commission on net winnings. One of the tightest exchange commissions in the UK market — meaningfully cheaper than Betfair’s tiered 2–5%.
• Sharp US-sports pricing. Matchbook has a reputation for particularly well-calibrated NFL, NBA and MLB lines. In a market dominated by European soccer exchanges, that’s unusual.
• Lower visible liquidity than Betfair, but tighter spreads. Less depth at the top of book, but often a narrower gap between best back and best lay — useful for traders who care about round-trip cost rather than raw size.

For anyone running a model that feeds off exchange prices, Matchbook is the data point that disagrees with Betfair often enough to matter. The question is just how to pull it without writing a Matchbook login flow.

The JSON Shape

Matchbook flows through OddsPapi’s standard exchange shape. The outcome block sits under bookmakerOdds.matchbook, and the order book depth is exposed via exchangeMeta:

# Matchbook exchange-type outcome
{
  "active": true,
  "betslip": "https://www.matchbook.com/...",
  "bookmakerOutcomeId": "12345678",
  "changedAt": "2026-04-11T09:38:17+00:00",
  "limit": 450.0,
  "price": 3.60,
  "exchangeMeta": {
    "availableToBack": [
      {"price": 3.60, "size": 450.0},
      {"price": 3.55, "size": 820.0}
    ],
    "availableToLay": [
      {"price": 3.65, "size": 310.0},
      {"price": 3.70, "size": 1150.0}
    ]
  }
}

The shape should look familiar if you’ve worked with Betfair Exchange through OddsPapi — it’s the same structure, because both venues publish full ladder depth. Best back is the top of availableToBack, best lay is the top of availableToLay, and the gap between them is the market’s round-trip cost.

Coverage note: Matchbook’s coverage depth on OddsPapi tracks where Matchbook itself has real liquidity — headline US sports, major soccer, horse racing. Niche fixtures will return an empty book; that’s the market, not the API.

Tutorial: Pull Matchbook Odds in Python

Step 1: Get Your API Key

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.oddspapi.io/v4"

Step 2: Find a Fixture Matchbook Will Cover

Matchbook’s deepest liquidity is on US sports and major European soccer. Start with the NBA if it’s in season, NFL otherwise.

from datetime import datetime, timezone, timedelta

today = datetime.now(timezone.utc)
params = {
    "apiKey": API_KEY,
    "sportId": 11,  # NBA
    "from": today.strftime("%Y-%m-%d"),
    "to": (today + timedelta(days=2)).strftime("%Y-%m-%d"),
}
fixtures = requests.get(f"{BASE_URL}/fixtures", params=params).json()
candidates = [f for f in fixtures if f.get("hasOdds")]

Step 3: Query Matchbook

fixture_id = candidates[0]["fixtureId"]

r = requests.get(
    f"{BASE_URL}/odds",
    params={
        "apiKey": API_KEY,
        "fixtureId": fixture_id,
        "bookmakers": "matchbook",
    },
)
data = r.json()

matchbook = data.get("bookmakerOdds", {}).get("matchbook")
if not matchbook:
    print("No Matchbook book on this fixture — try another.")
else:
    print(f"{len(matchbook['markets'])} markets from Matchbook")

Step 4: Parse Best Back + Lay

# Market 101 = Full Time Result / Moneyline
market = matchbook["markets"]["101"]
labels = {"101": "Home", "102": "Draw", "103": "Away"}

for oid, label in labels.items():
    outcome = market["outcomes"].get(oid)
    if not outcome:
        continue

    p = outcome["players"]["0"]
    if not p["active"]:
        continue

    meta = p.get("exchangeMeta") or {}
    back = meta.get("availableToBack", [])
    lay = meta.get("availableToLay", [])

    best_back = back[0]["price"] if back else None
    best_lay = lay[0]["price"] if lay else None
    back_size = back[0]["size"] if back else 0
    lay_size = lay[0]["size"] if lay else 0

    spread_pct = None
    if best_back and best_lay:
        spread_pct = (best_lay - best_back) / best_back * 100

    print(f"{label}: back @ {best_back} (£{back_size}) | lay @ {best_lay} (£{lay_size}) | spread {spread_pct:.2f}%")

That spread is the round-trip cost of crossing the book. On a healthy Matchbook market it should be well under 1%. When it’s not, liquidity is thin and you should treat the price as indicative, not tradeable.

Step 5: Matchbook vs Betfair vs Pinnacle

The actual use case. Pull Matchbook side by side with Betfair Exchange (the other UK exchange) and Pinnacle (the sharpest sportsbook), and look for disagreement.

r = requests.get(
    f"{BASE_URL}/odds",
    params={
        "apiKey": API_KEY,
        "fixtureId": fixture_id,
        "bookmakers": "matchbook,betfair-ex,pinnacle",
    },
)
books = r.json()["bookmakerOdds"]

def best_back(book):
    m = book.get("markets", {}).get("101", {})
    home = m.get("outcomes", {}).get("101", {}).get("players", {}).get("0", {})
    meta = home.get("exchangeMeta") or {}
    if "availableToBack" in meta and meta["availableToBack"]:
        return meta["availableToBack"][0]["price"]
    return home.get("price")

for slug in ("matchbook", "betfair-ex", "pinnacle"):
    if slug in books:
        print(f"{slug:12} home @ {best_back(books[slug])}")

If Matchbook’s back price beats Betfair’s, your size clears there first. If it beats Pinnacle’s no-vig implied probability, that’s an edge.

Why Devs Pick OddsPapi Over the Matchbook API

No account required — Matchbook’s API needs a funded, KYC-verified account. OddsPapi needs an email address.

No session management — Matchbook’s token flow expires. OddsPapi auth is one query parameter, never expires.

Compare with the rest of the market — Matchbook vs Betfair vs SX Bet vs 4casters vs Pinnacle, in one response. That’s the entire UK-and-global exchange stack in a single call.

Free historical data — /v4/historical-odds?fixtureId=…&bookmakers=matchbook gives you the full price history. Matchbook doesn’t sell a historical product directly.

No redistribution headaches — OddsPapi’s terms are built for developer use. Matchbook’s direct API explicitly is not.

Get Started

1. Sign up at oddspapi.io
2. Copy your API key
3. Query Matchbook in one curl

curl "https://api.oddspapi.io/v4/odds?apiKey=YOUR_KEY&fixtureId=id1100022762690473&bookmakers=matchbook"

No session token. No KYC. No Alderney jurisdiction check. Just clean Matchbook back/lay prices with the ladder attached.