Stop burning your quota on polling loops. One socket per sport streams every
price change from 45+ sportsbooks and sources - a snapshot on connect, then an
odds_update frame the moment a book moves. Most odds APIs don't
offer this at any price; here's the honest map of the ones that do, and a
quickstart you can run in 60 seconds.
"Sports odds WebSocket" is a short shopping list. Most REST odds APIs stop at polling, and the vendors that do stream either gate it behind their top self-serve tier or behind a sales call. Competitor figures below come from their own public pages, read on the dates shown.
| Provider | WebSocket / push streaming | Where streaming starts |
|---|---|---|
| the-odds-api | Not offered - no WebSocket, SSE, or push option disclosed on their site at any tier Fair's fair: their REST polling is simple to operate, and their published high-volume plans make heavy polling cheap if a 30–60s loop is fresh enough for you. | - (REST polling only) |
| TheRundown | Yes - "WebSocket real-time push" on the Ultra plan; Starter ($49/mo) and Pro ($149/mo) explicitly say "No WebSocket streaming" Fair's fair: their stream is sub-second on sharp books, and their platform bundles scores, player stats, and +EV calculations. | Ultra, $399/mo |
| Enterprise feeds (Sportradar, OpticOdds) | Yes - real-time feeds are their core product Fair's fair: for licensed operators needing official data rights and SLAs, this class of vendor is the right answer. | Quote-based - a sales call before you see a number |
| ParlayAPI | Yes - WebSocket + SSE, one socket per sport, game lines and player props
Not on Free, Starter, or Pro: those keys are rejected at handshake (close code 4001). We'd rather tell you here than after checkout. |
Business tier and up - current numbers at /pricing, self-serve, plus a 24-hour Scale trial from the dashboard |
Sources: the-odds-api.com (read 2026-08-25 - plans and features listed on their homepage include no streaming option); therundown.io/pricing (read 2026-08-25 - Ultra $399/mo is the first plan listing "WebSocket real-time push"); Sportradar and OpticOdds publish no self-serve streaming price on their sites (as of 2026-08; see our OpticOdds and Sportradar comparisons). If any of this is out of date, tell us and we'll fix it.
On connect you get a connected envelope (~1 ms), an
initial_state snapshot (~200 ms, up to 500 current rows), then
an odds_update frame each time a price changes - silent when
nothing moves, with heartbeat keepalives. No diffing polls,
no missed moves between requests.
wss://parlay-api.com/v1/ws/odds/{sport_key}
Stream any of the 90+ sport keys from GET /v1/sports. Use
/v1/ws/live/ for in-play-only updates, and the props feed for
player-prop streaming - the pipeline behind it writes roughly half a
million prop updates an hour across 4,000+ distinct market keys.
wss: /v1/ws/live/{sport_key}
Send a subscribe frame with an event_id and the
socket narrows to that game - the pattern behind single-game dashboards
and edge alerts that fire when a
book lags the market.
Same feed over Server-Sent Events for serverless platforms, strict
proxies, or EventSource front ends - same frames, same
Business-and-up tiers. SSE docs →
Honestly: most integrations don't. REST polling on every ParlayAPI tier - including the free one - reads from the same pipeline with sub-5-second freshness on major books, and a 30–60 second poll is plenty for model refreshes, content sites, and most tools. A socket earns its keep when you're alerting on line moves, trading on them, or polling so hard that streaming is cheaper than the credit burn. If that's not you yet, start on the free tier and upgrade when it is.
From the live WebSocket quickstart in our docs. You need a Business+ key (or the 24-hour Scale trial from the dashboard); auth is a query param because browsers can't set custom headers on a WebSocket.
wss://parlay-api.com/v1/ws/odds/{sport_key}?apiKey=YOUR_KEY
# any sport key from GET /v1/sports works: americanfootball_nfl, basketball_nba, baseball_mlb ...
# use /v1/ws/live/{sport_key} for live-game-only updates
import WebSocket from "ws"; const KEY = process.env.PARLAY_API_KEY; const ws = new WebSocket(`wss://parlay-api.com/v1/ws/odds/americanfootball_nfl?apiKey=${KEY}`); ws.on("message", (buf) => { const frame = JSON.parse(buf.toString()); if (frame.type === "connected") { console.log(`[connected] tier=${frame.tier} push_mode=${frame.push_mode}`); } else if (frame.type === "initial_state") { console.log(`[snapshot] ${frame.count} rows`); } else if (frame.type === "odds_update") { for (const row of frame.data.slice(0, 3)) { console.log(`[update] ${row.bookmaker} ${row.market_key} ${row.outcome} -> ${row.price_american}`); } } });
curl --include --no-buffer \ --header "Connection: Upgrade" \ --header "Upgrade: websocket" \ --header "Sec-WebSocket-Key: $(head -c 16 /dev/urandom | base64)" \ --header "Sec-WebSocket-Version: 13" \ --header "X-API-Key: $PARLAY_API_KEY" \ "https://parlay-api.com/v1/ws/odds/baseball_mlb" # success = HTTP/1.1 101 Switching Protocols
Python and browser versions, plus production-grade reference clients with the correct silent-watchdog and capped-backoff reconnect logic, are in the full quickstart and on GitHub.
Eight pages, written for people running real sockets in production - not just a hello-world.
Every frame, every field, every close code.
Node, Python, and browser in 60 seconds.
Go, Ruby, Java, PHP, React, Discord bots.
Prop feeds, filtering by player.
Pinnacle-anchored alerts, Discord webhooks.
The same feed over Server-Sent Events.
Moving an existing poller onto the socket.
Close codes, proxies, the three causes of socket silence.
Fewer than you'd expect. As of August 2026: the-odds-api discloses no WebSocket or push-streaming option on its site at any tier - it is REST polling only. TheRundown offers WebSocket delivery starting on its Ultra plan at $399/month (its Starter and Pro plans explicitly exclude it, per therundown.io/pricing, read 2026-08-25). Enterprise feeds like Sportradar and OpticOdds stream, but pricing is quote-based - you talk to sales before you see a number. ParlayAPI includes WebSocket and SSE streaming on Business tier and up; current tier pricing is at /pricing.
WebSocket and SSE streaming are included on Business tier and
up. Free, Starter, and Pro keys are rejected at the WebSocket
handshake with close code 4001 - we'd rather say that plainly
than surprise you after an upgrade. Current tier pricing is at
/pricing, and a 24-hour Scale trial is available from
the dashboard so you can test the stream before paying. Every tier, including
free, gets REST polling with sub-5-second freshness on major books.
Three frame types, in order: a connected envelope within about
a millisecond (your tier, push mode, coalesce window), an
initial_state snapshot within about 200 ms (up to 500 current
odds rows), then an odds_update frame each time a price changes -
silent when nothing is moving, with periodic heartbeat frames as
keepalive. Platform-wide the pipeline behind it processes 100k+ game-line
updates and roughly half a million prop updates per hour. You can also send a
subscribe frame to filter the socket down to a single event.
No - as of 2026-08-25, the-odds-api.com discloses no WebSocket, SSE, or push-streaming option anywhere on its site; its model is REST polling against your monthly request quota. To be fair, that simplicity is part of its appeal: polling is easier to operate than a socket, and the-odds-api's high-volume plans (published on its homepage) make aggressive polling affordable. If you genuinely need pushed line movement, though, you need a different provider - see our honest roundup of the-odds-api alternatives.
Yes. The same live feed is available over Server-Sent Events for
environments where a raw WebSocket is awkward - serverless platforms, strict
proxies, or EventSource-based front ends. It carries the same
frames on the same Business-and-up tiers. See
/docs/websocket/sse for the endpoint and
examples.
NFL kickoff is September 9. Watch the live stream demo with no account, start on the free REST tier (1,000 credits a month, no card), and take the 24-hour Scale trial when you're ready to test the socket.