Odds Feed API: Real-Time Data from 350+ Bookmakers (Free Tier)
What Is an Odds Feed API?
An odds feed API is a structured data pipeline that delivers real-time bookmaker odds to your application via HTTP or WebSocket. If you’re building an odds comparison site, a sportsbook platform, a trading desk, or an arbitrage scanner, you need a feed that goes beyond the 40 soft bookmakers that generic APIs offer.
The problem: enterprise feeds from Sportradar or OddsMarket start at $5,000+/month and require sales calls. Generic APIs like The Odds API cap out at ~40 bookmakers — all softs, no sharps, no crypto books.
OddsPapi is the third option. 350+ bookmakers (including sharps like Pinnacle, Singbet, and SBOBet), 59 sports, JSON format, and a free tier that includes historical data. REST polling or WebSocket streaming — your choice.
What’s in the Feed: 350+ Bookmakers, 59 Sports
The OddsPapi odds feed covers every bookmaker category that matters for serious betting infrastructure:
| Category | Example Bookmakers | Count |
|---|---|---|
| Sharps | Pinnacle, Singbet (Crown), SBOBet | 3+ |
| Softs (Global) | Bet365, Betway, Unibet, William Hill, Ladbrokes | 50+ |
| US Sportsbooks | DraftKings, FanDuel, BetMGM, BetRivers, Hard Rock | 15+ |
| Crypto / Niche | 1xBet, Stake, BC.Game, Cloudbet, Rollbit | 20+ |
| Exchanges | Betfair Exchange, Polymarket, Kalshi | 3 |
| Regional (Brazil) | EstrelaBet, Sportingbet BR, Superbet BR, Blaze, KTO | 15+ |
| Regional (Europe) | Betano, SNAI, Sisal, Eurobet, Goldbet, ZeBet | 40+ |
On a single English Premier League fixture, the feed typically returns 130+ bookmakers with odds across 50-100+ markets. Here’s the JSON structure you’ll receive:
# Odds response structure (simplified)
{
"fixtureId": "id1000001761301055",
"bookmakerOdds": {
"pinnacle": {
"markets": {
"101": { # Full Time Result (1X2)
"outcomes": {
"101": { # Home Win
"players": {
"0": { "price": 8.25 }
}
},
"102": { # Draw
"players": {
"0": { "price": 4.55 }
}
},
"103": { # Away Win
"players": {
"0": { "price": 1.46 }
}
}
}
}
}
},
"bet365": { ... },
"1xbet": { ... },
// 130+ more bookmakers
}
}
Each bookmaker object contains nested markets, outcomes, and player-level pricing. The path to any price is always:
price = response['bookmakerOdds'][slug]['markets'][marketId]['outcomes'][outcomeId]['players']['0']['price']
Sports coverage spans 59 sports — every major traditional sport plus esports (CS2, LoL, Dota 2, Valorant), prediction markets (Polymarket, Kalshi), and niche events.
Pinnacle Odds Feed: Sharp Lines Without Enterprise Access
Pinnacle is the benchmark for sharp bettors. Lowest vig in the industry, no account limits for winners, and their closing line efficiency is the standard that quantitative models are measured against. If you’re building anything that involves line comparison, CLV analysis, or model validation, you need Pinnacle data.
The problem: Pinnacle’s own API is closed to the public. You need a commercial account with volume requirements to get access. Their documentation exists, but the endpoints are gated behind enterprise approval.
OddsPapi aggregates Pinnacle odds alongside 350+ other bookmakers, accessible with a free API key. No sales calls, no commercial account needed.
import requests
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.oddspapi.io/v4"
# Get odds for a Premier League fixture
response = requests.get(f"{BASE_URL}/odds", params={
"apiKey": API_KEY,
"fixtureId": "id1000001766905890"
})
data = response.json()
# Extract Pinnacle vs Bet365 1X2 odds
pinnacle = data["bookmakerOdds"]["pinnacle"]["markets"]["101"]["outcomes"]
bet365 = data["bookmakerOdds"]["bet365"]["markets"]["101"]["outcomes"]
labels = {"101": "Home", "102": "Draw", "103": "Away"}
print(f"{'Outcome':<10} {'Pinnacle':>10} {'Bet365':>10} {'Edge':>10}")
print("-" * 42)
for oid in ["101", "102", "103"]:
pinn_price = pinnacle[oid]["players"]["0"]["price"]
b365_price = bet365[oid]["players"]["0"]["price"]
edge = ((b365_price / pinn_price) - 1) * 100
print(f"{labels[oid]:<10} {pinn_price:>10.3f} {b365_price:>10.3f} {edge:>+9.1f}%")
Output (Everton vs Manchester United):
Outcome Pinnacle Bet365 Edge
------------------------------------------
Home 3.770 3.600 -4.5%
Draw 3.900 3.800 -2.6%
Away 1.952 1.950 -0.1%
This is how you build a line shopping tool: fetch Pinnacle as the benchmark, compare every other bookmaker, and flag the edges. For a deeper dive into accessing Pinnacle data, see our Pinnacle Odds API guide.
Bet365 Odds Feed via API
Bet365 is the world’s largest online bookmaker by volume. They have no public API — zero documentation, no developer portal, no OAuth flow. If you want Bet365 odds programmatically, your options are scraping (fragile, against ToS, constant breakage) or an aggregator.
OddsPapi includes Bet365 odds in the same unified feed as every other bookmaker. Same JSON structure, same endpoint, same API key.
import requests
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.oddspapi.io/v4"
# Get all odds for a fixture
response = requests.get(f"{BASE_URL}/odds", params={
"apiKey": API_KEY,
"fixtureId": "id1000001766905890"
})
data = response.json()
# Filter Bet365 markets
bet365 = data["bookmakerOdds"]["bet365"]["markets"]
print(f"Bet365 markets available: {len(bet365)}")
# Show market IDs
market_names = {
"101": "Full Time Result",
"104": "Both Teams To Score",
"1010": "Over/Under 2.5 Goals",
"1068": "Asian Handicap -0.5"
}
for mid, name in market_names.items():
if mid in bet365:
outcomes = bet365[mid]["outcomes"]
prices = []
for oid, o in outcomes.items():
price = o["players"]["0"]["price"]
prices.append(f"{oid}={price}")
print(f" {name}: {', '.join(prices)}")
On a major Premier League match, Bet365 typically provides 100+ markets including 1X2, Asian Handicaps, Over/Under lines, BTTS, correct score, and more. For historical Bet365 data and backtesting strategies, see our Bet365 Historical Odds guide.
REST API vs WebSocket: Choosing Your Feed Method
OddsPapi delivers odds data through two channels. Which one you need depends on what you’re building.
| Feature | REST API (Polling) | WebSocket (Push) |
|---|---|---|
| Delivery | Request/response — you poll | Server pushes updates to you |
| Latency | Depends on poll interval (seconds) | Sub-second updates |
| Best For | Pre-match, line shopping, backtesting | Live betting, arb detection, trading |
| Data Format | JSON over HTTPS | JSON over WebSocket |
| Free Tier | Yes — 350+ bookmakers included | Pro tier |
| Complexity | Simple — standard HTTP requests | Moderate — persistent connection |
| Rate Limits | Per-plan request quotas | Streaming — no polling needed |
When to Use REST Polling
REST is the right choice for most use cases: odds comparison sites, pre-match analytics, model training, backtesting, and any workflow where you don’t need sub-second updates. You poll the API on your schedule, parse the JSON, and process the data.
# REST: Poll for odds every 30 seconds
import requests, time
API_KEY = "YOUR_API_KEY"
while True:
response = requests.get("https://api.oddspapi.io/v4/odds", params={
"apiKey": API_KEY,
"fixtureId": "id1000001766905890"
})
odds = response.json()
bookmakers = odds["bookmakerOdds"]
print(f"[{time.strftime('%H:%M:%S')}] {len(bookmakers)} bookmakers updated")
time.sleep(30)
When to Use WebSocket
WebSocket is for latency-sensitive applications: live in-play arbitrage detection, automated trading, real-time dashboards where every millisecond matters. The server pushes odds changes to your client as they happen — no polling delay.
WebSocket access is available on Pro tier plans. For a detailed technical comparison, see our WebSocket Odds API guide.
Odds Feed Providers Compared (2026)
Here’s how OddsPapi stacks up against other odds feed providers in the market:
| Provider | Bookmakers | Sports | Format | Free Tier | WebSocket | Best For |
|---|---|---|---|---|---|---|
| OddsPapi | 350+ | 59 | JSON | Yes | Yes (Pro) | Broadest coverage + free tier |
| OddsMarket | 300+ | 30+ | XML / JSON | No | Yes | Enterprise B2B, XML integrations |
| OpticOdds | 200+ | 20+ | JSON | No | Yes | Fastest live latency |
| The Odds API | ~40 | 18 | JSON | Yes (limited) | No | Simple US/UK sportsbook coverage |
| OddsJam | 100+ | 10+ | JSON | No | No | Consumer-facing arb tool |
| Sportradar | 600+ | 70+ | XML / JSON | No | Yes | Enterprise — $10K+/month |
Key differentiators: OddsPapi is the only provider that combines 350+ bookmakers (including sharps and crypto books) with a free tier. OpticOdds claims faster live latency for in-play trading. OddsMarket offers XML feeds for legacy integrations. The Odds API is simpler but limited to ~40 soft bookmakers. Sportradar is the enterprise standard but priced accordingly.
If you need the broadest bookmaker coverage at a developer-friendly price, OddsPapi is the clear choice. If you need the absolute fastest live feed for high-frequency trading, OpticOdds is worth evaluating. If you need XML, OddsMarket has it.
Python Tutorial: Connect to the Odds Feed in 5 Minutes
Everything below uses tested code against the live OddsPapi API. Copy, paste, replace YOUR_API_KEY, and run.
Step 1: Get Your API Key
Sign up at oddspapi.io — free tier, no credit card. Your API key goes in the apiKey query parameter (not a header).
import requests
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.oddspapi.io/v4"
# Verify your key works
response = requests.get(f"{BASE_URL}/sports", params={"apiKey": API_KEY})
print(f"Status: {response.status_code}") # 200 = good
Step 2: Discover Available Sports
response = requests.get(f"{BASE_URL}/sports", params={"apiKey": API_KEY})
sports = response.json()
print(f"Total sports: {len(sports)}\n")
for sport in sports[:10]:
print(f" ID {sport['sportId']:>3}: {sport['sportName']}")
Output:
Total sports: 59
ID 10: Soccer
ID 11: Basketball
ID 13: Tennis
ID 14: American Football
ID 16: Baseball
ID 17: Ice Hockey
ID 18: League of Legends
ID 19: Dota 2
ID 20: CS2
ID 22: MMA
Step 3: Get Fixtures with Odds
from datetime import datetime, timedelta, timezone
now = datetime.now(timezone.utc)
from_date = now.strftime("%Y-%m-%dT%H:%M:%SZ")
to_date = (now + timedelta(days=3)).strftime("%Y-%m-%dT%H:%M:%SZ")
response = requests.get(f"{BASE_URL}/fixtures", params={
"apiKey": API_KEY,
"sportId": 10, # Soccer
"from": from_date,
"to": to_date,
"hasOdds": "true" # Only fixtures with odds
})
fixtures = response.json()
print(f"Soccer fixtures (next 3 days): {len(fixtures)}\n")
for f in fixtures[:5]:
print(f" {f['participant1Name']} vs {f['participant2Name']}")
print(f" Tournament: {f['tournamentName']}")
print(f" Fixture ID: {f['fixtureId']}")
print(f" Kickoff: {f['startTime']}\n")
Step 4: Fetch Odds Across All Bookmakers
fixture_id = fixtures[0]["fixtureId"]
response = requests.get(f"{BASE_URL}/odds", params={
"apiKey": API_KEY,
"fixtureId": fixture_id
})
data = response.json()
bookmakers = data["bookmakerOdds"]
print(f"Bookmakers with odds: {len(bookmakers)}")
print(f"Sample slugs: {list(bookmakers.keys())[:10]}")
Step 5: Build a Simple Odds Comparison
# Compare 1X2 odds across Pinnacle, Bet365, and 1xBet
targets = ["pinnacle", "bet365", "1xbet"]
labels = {"101": "Home", "102": "Draw", "103": "Away"}
print(f"{'Outcome':<10}", end="") for slug in targets: print(f"{slug:>12}", end="")
print()
print("-" * 46)
for oid, label in labels.items():
print(f"{label:<10}", end="") for slug in targets: try: price = bookmakers[slug]["markets"]["101"]["outcomes"][oid]["players"]["0"]["price"] print(f"{price:>12.3f}", end="")
except KeyError:
print(f"{'N/A':>12}", end="")
print()
Output (Premier League fixture):
Outcome pinnacle bet365 1xbet
----------------------------------------------
Home 3.770 3.600 3.570
Draw 3.900 3.800 3.880
Away 1.952 1.950 2.020
Step 6: Historical Odds for Backtesting
OddsPapi includes historical odds on the free tier — most competitors charge extra for this. Every odds movement is timestamped, so you can reconstruct line movement and measure closing line value (CLV).
response = requests.get(f"{BASE_URL}/historical-odds", params={
"apiKey": API_KEY,
"fixtureId": fixture_id,
"bookmakers": "pinnacle",
"marketId": 101 # Full Time Result (1X2)
})
history = response.json()
# Get Pinnacle Home Win line movement
snapshots = history["bookmakers"]["pinnacle"]["markets"]["101"]["outcomes"]["101"]["players"]["0"]
print("Pinnacle Home Win — Line Movement")
print(f"{'Timestamp':<30} {'Price':>8}")
print("-" * 40)
for snap in snapshots[:5]:
print(f"{snap['createdAt']:<30} {snap['price']:>8.3f}")
Output:
Pinnacle Home Win — Line Movement
Timestamp Price
----------------------------------------
2026-02-22T16:05:11.364684+00:00 8.250
2026-02-22T16:00:35.492689+00:00 8.050
2026-02-22T16:00:23.929521+00:00 8.000
2026-02-22T15:53:30.390068+00:00 7.950
2026-02-22T15:43:03.304789+00:00 7.850
What Can You Build with an Odds Feed?
The OddsPapi odds feed is infrastructure. What you build on top depends on your use case:
| Use Case | What You Need | OddsPapi Feature |
|---|---|---|
| Odds Comparison Website | Pre-match odds from 100+ books | REST API (free tier) |
| Sportsbook Platform | Bulk feed for all sports/markets | REST API + full bookmaker coverage |
| Arbitrage Scanner | Real-time odds + low latency | WebSocket (Pro) or REST polling |
| Line Shopping Tool | Cross-bookmaker comparison | REST API (free tier) |
| Trading Desk | Sharp lines + exchange data | Pinnacle + Betfair Exchange odds |
| Predictive Model | Historical odds for training | Historical odds API (free tier) |
| CLV Tracker | Closing line data per bookmaker | Historical odds with timestamps |
| White-Label Platform | Full market feed for resale | REST + WebSocket + all markets |
The free tier covers most pre-match use cases — odds comparison, line shopping, model training, and backtesting. WebSocket and sub-second latency are Pro tier features for live betting and arbitrage detection.
Odds Feed API FAQ
What is an odds feed API?
An odds feed API is a structured data service that delivers real-time bookmaker odds to your application. It provides pricing data from multiple sportsbooks in a standardized format (JSON), enabling you to build odds comparison sites, trading tools, arbitrage scanners, and betting platforms.
Is the OddsPapi odds feed free?
Yes. The free tier includes REST API access to 350+ bookmakers, 59 sports, and historical odds data. No credit card required. WebSocket streaming is available on Pro tier plans.
What format is the odds data?
JSON format via REST API (HTTPS) or WebSocket push. The JSON response contains nested bookmaker objects with markets, outcomes, and player-level pricing.
Does the feed include Pinnacle odds?
Yes. OddsPapi includes Pinnacle (sharp), Bet365, 1xBet, DraftKings, FanDuel, Betfair Exchange, and 350+ other bookmakers. Pinnacle’s own API is closed to the public — OddsPapi is one of the few ways to access their odds programmatically.
What is the update frequency?
REST API: odds are updated continuously and available whenever you poll. WebSocket: sub-second push updates as odds change. For pre-match markets, polling every 15-60 seconds is typical. For live betting, WebSocket provides the lowest latency.
Can I get XML odds feeds?
OddsPapi uses JSON format exclusively. If you need XML feeds, OddsMarket offers XML/JSON options. For most modern applications, JSON is the preferred format and is easier to parse in any programming language.
Start Building
350+ bookmakers. 59 sports. JSON format. Historical data included. Free forever.
Get your free API key — no credit card, no sales call, no enterprise approval. Start pulling odds in under 5 minutes.