TheRundown developer API
Odds feed API for live sportsbook odds
TheRundown is an odds feed provider for developers. Lines and prices from 25+ books arrive in one JSON schema: REST snapshots on every plan and a real-time WebSocket push feed on Ultra and above. Every price carries the same event, market and participant IDs across books, so you integrate one feed instead of one per sportsbook.
Free: delayed pre-match main lines from three books. No credit card. Real-time REST and WebSocket require Ultra or above.
What the odds feed carries
The feed covers 23 leagues + 9 season variants and 550+ market types from 25+ books. Each price belongs to an event, a market, a participant, a signed line and a sportsbook, and the same event carries the score and game status. Coverage varies by book, sport and event, so confirm the books and markets your product needs with a sample request before you build.
Ask for only the scope you use. Filter by sport, date, event, market and sportsbook, and set main_line=true to leave out alternate lines. Price rows you do not request are not delivered and do not count toward your plan’s data points.
| Feed content | What you get | Plans |
|---|---|---|
| Main lines | Moneyline, spread and total (market IDs 1, 2 and 3) at each book | Every plan; Free is pre-match only |
| In-play prices | Moneyline, spread and total during the game (market IDs 41, 42 and 43) | Starter and above; delayed below Ultra |
| Props and alternate lines | Player and game props, with each alternate rung as its own signed line | Starter and above |
| Futures | Futures prices, such as season winners | Ultra and above |
| Scores and game status | The score and event status on the same event as its odds | Every plan |
Push feed or pull API: how the odds arrive
An odds feed pushes each price change to your server as it happens. An odds API returns the current state when you ask. TheRundown offers both in one schema, so you can start with REST snapshots and add the push feed later without remapping IDs.
Below Ultra, prices are delayed by plan: five minutes on Free, 60 seconds on Starter and 30 seconds on Pro. Read the X-Data-Delay-Seconds header on each response to confirm the delay your key gets.
| Delivery | How it works | Plans | What it bills |
|---|---|---|---|
| REST snapshot | Request a scope (sport, date, books, markets) and get its full current state back | Every plan | The price rows each response returns |
| REST delta | After a zero-delay snapshot, request only the rows changed since meta.delta_last_id | Zero-delay keys: Ultra and above | The price rows each response returns |
| WebSocket markets stream | wss://therundown.io/api/v2/ws/markets pushes each price change, filtered in the connection URL | Ultra and above | One data point per price message; heartbeats are free |
| WebSocket multiplexed | wss://therundown.io/api/v2/ws carries markets, scores, plays, stats, futures and live subscriptions on one connection | Ultra: 1 connection, up to 3 subscriptions; more on higher plans | Price messages as above; snapshot frames bill like REST |
Read one message from the push feed
Each WebSocket message is one price change for one participant, market and sportsbook, not a market snapshot. It carries event_id, affiliate_id (the sportsbook), market_id, normalized_market_participant_id, line, price and updated_at. A new or closing row can omit previous_price and price_delta, so read both with a fallback.
Connect from your server with X-TheRundown-Key in the handshake. Browsers cannot set that header, so a web app reads the feed through your own backend. The server sends a heartbeat every 15 seconds; if nothing arrives for about a minute, reconnect with backoff and load a REST snapshot before you apply new messages, because the feed carries only changes.
import asyncio
import json
import os
import websockets # pip install "websockets>=14"
URL = ("wss://therundown.io/api/v2/ws/markets"
"?sport_ids=4&market_ids=1,2,3&affiliate_ids=19&main_line=true")
async def main():
key = os.environ["THERUNDOWN_API_KEY"]
async with websockets.connect(
URL, additional_headers={"X-TheRundown-Key": key}
) as feed:
async for raw in feed:
message = json.loads(raw)
if message.get("meta", {}).get("type") != "market_price":
continue # heartbeats arrive every 15 seconds
price = message["data"]
print(price["event_id"], price["market_id"], price.get("line"),
price["price"], price.get("previous_price"))
asyncio.run(main())A minimal reader for one book’s NBA main lines on Ultra. market_ids=1,2,3 also delivers in-play messages tagged 41, 42 and 43. A production client adds the reconnect and REST reload described above.
How to compare odds feed providers
Feed providers differ more on coverage, delay, identity and billing than on transport. Test each one with the books, leagues and markets your product needs, and measure delivery on your own servers rather than relying on a published latency claim.
| Check | What to ask | TheRundown |
|---|---|---|
| Coverage | Do the books and markets you need publish today, for your sports? | 25+ books and 550+ market types; /api/v2/affiliates returns the current roster |
| Delay | What delay does your plan get, and can you see it on each response? | Real-time on Ultra; 30 seconds on Pro, 60 on Starter, five minutes on Free; X-Data-Delay-Seconds on each response |
| Identity | Can you join one game across books without matching team names? | One event, market and participant ID across books, scores and play-by-play |
| Closures | Does the feed say when a price comes off the board? | A closed price carries closed_at; a reopened price drops it |
| Billing unit | Are you billed per request, per event or per price row? | Data points: returned price rows on REST and one per pushed price message; X-Datapoints on each response |
| Recovery | How do you rebuild state after a disconnect? | A heartbeat every 15 seconds; reload a REST snapshot, then apply new messages |
Odds feed API pricing and plan delays
Published USD monthly plans start at Free, Starter $49, Pro $149 and Ultra $399. The real-time WebSocket feed begins on Ultra, with one connection and up to three subscriptions; Super, Mega and Max add connection capacity. Free and Starter are for internal or personal use; commercial end-user display begins on Pro. Each plan includes a monthly data-point volume, so request only the books and markets you show and measure each response with X-Datapoints.
| Monthly plan | USD/month | Odds delay | Included volume | Use and delivery |
|---|---|---|---|---|
| Free | $0 | 5 minutes | 20,000/day · 200,000/month | Three books; delayed pre-match main lines. Internal or personal use. |
| Starter | $49 | 60 seconds | 25,000,000/mo | Additional books, props, alternates and delayed in-play odds. Internal or personal use. |
| Pro | $149 | 30 seconds | 125,000,000/mo | Commercial end-user display and a 30-second odds delay. |
| Ultra | $399 | Real-time | 500,000,000/mo | Real-time REST, WebSocket, futures and supported live game data. |
Annual billing has different monthly equivalents. Monthly and annual plans stop at included data points by default; optional overage and weekly billing have separate terms. Super, Mega and Max add published volume and connection capacity; Enterprise is scoped by contract. Confirm effective API and stats access in response headers.
Odds feed API FAQ
- What is an odds feed API?
- An odds feed API delivers sportsbook lines and prices to your application as structured data, either pushed as prices change or returned when you ask. TheRundown’s feed covers 25+ books in one JSON schema, with REST on every plan and a WebSocket push feed on Ultra and above.
- Is the odds feed real-time?
- On Ultra ($399 a month) and above, REST and WebSocket are real-time. Pro is delayed 30 seconds, Starter 60 seconds and Free five minutes. The X-Data-Delay-Seconds header shows the delay on each response.
- What format does the odds feed use?
- JSON. A REST response returns events with their markets, participants and prices. A WebSocket message is one price change with its event, market, participant, line, price and sportsbook IDs.
- Which sportsbooks are in the odds feed?
- Lines and prices come from 25+ books, including BookMaker, BetCRIS, Circa Sports, Heritage Sports, Bet105, Kalshi, Polymarket, Polymarket US, Novig, and ProphetX. The /api/v2/affiliates endpoint returns the current roster, and availability varies by book, sport and market.
- How much does an odds feed cost?
- Free covers five-minute-delayed pre-match main lines from three books, with no card. Paid plans start at Starter, $49 a month. The real-time WebSocket feed starts on Ultra at $399 a month, and every plan includes a monthly data-point volume.
- Is there a free odds feed?
- Yes, for evaluation. A free key returns five-minute-delayed pre-match main lines from three books, up to 20,000 data points a day and 200,000 a month, with no credit card. It leaves out in-play odds, props, alternate lines and the WebSocket feed.
- Do WebSocket feed messages count as data points?
- Yes. Each pushed price message is one data point, and heartbeats are free. WebSocket traffic does not count against your request rate limit.
- Does the odds feed include scores?
- Yes. Scores and game status sit on the same event as its odds, and on the multiplexed WebSocket a scores subscription can share one connection with a markets subscription.
Build and compare
Choose the API scope that matches your application. Each guide below covers a different integration need.
Product and documentation sources checked October 13, 2026. Source, sport, event and market availability varies; catalog entries do not guarantee a priced line or a populated statistic.