BoltOdds API Review 2026

BoltOdds is a sports odds API built around WebSocket streaming. Where most odds APIs start with REST and bolt on a WebSocket later, BoltOdds leads with the socket. You connect, subscribe to sports and sportsbooks, and receive odds updates as JSON messages with near-zero latency. REST endpoints exist for reference data and specific lookups, but the primary data path is the stream.

The product covers 40+ sportsbooks, exchanges and prediction markets across a wide set of sports: NFL, NBA, MLB, NHL, soccer (50+ competitions), tennis, golf, combat sports, esports, and motorsports. It also includes a same-game parlay (SGP) pricing engine that returns correlated parlay prices from the sportsbooks themselves, not a generic multiplier. If you are building a tool that needs live odds and SGP pricing together, the combination is uncommon in a single API.

The sport and league list is broad for an API at this price point:

• US majors: NFL, NBA, MLB, NHL, NCAAB, NCAAF, WNBA, CFL.
• Soccer: 50+ competitions, including the Premier League, La Liga, Champions League, and World Cup qualifiers.
• Tennis: Grand Slams, ATP, WTA, ITF.
• Golf: PGA Tour, LIV, LPGA, majors.
• Combat: UFC and boxing.
• Esports: League of Legends, Valorant, CS2, Dota 2, and more.
• Motorsports: F1, NASCAR, IndyCar.

Sportsbooks include DraftKings, FanDuel, BetMGM, Caesars, Hard Rock, Stake, Polymarket, and others. Markets cover moneylines, spreads, totals, player props, and same-game parlays. Every odds outcome includes a sportsbook deeplink, so you can route users straight to the bet slip.

Know the gaps. BoltOdds now lists bet365, but Pinnacle is not in the feed (checked November 2026). There are no closing odds and no futures markets, and the historical archive sits on the Enterprise plan only. If your model prices against sharp books or needs closing-line value for grading, you will need a separate source. See the Pinnacle API guide for providers that carry those lines.

Four tiers, with a 3-day free trial (the pricing page asks for a card and charges nothing if you cancel inside the 3 days):

• Starter ($149/mo): real-time WebSocket, all sportsbooks, 1 sport league per connection, 1 market per connection, 1 concurrent connection.
• Growth ($349/mo): up to 3 sport leagues per connection, all markets, 1 concurrent connection.
• Pro ($599/mo): all leagues, 3 concurrent connections, pre-built parlays endpoint, priority support.
• Enterprise: contact for pricing. Adds custom sports/markets, custom sportsbooks, SGP pricing engine, and historical odds.

Annual plans save 20%. The free trial runs 3 days with access to almost all features, enough time to connect the WebSocket, test the subscription filters, and measure latency in your own environment.

The Starter tier is restrictive. One league and one market per connection means you cannot stream NFL moneylines and NBA spreads at the same time without opening a second connection, which the plan does not allow. Most developers who need more than a single sport will land on Growth at $349 or Pro at $599. The SGP pricing engine and historical odds are reserved for the Enterprise tier, so ask about pricing before you build around those features.

The WebSocket connection authenticates via an API key in the query string: wss://spro.agency/api?key=YOUR_TOKEN. After connecting, you send subscription messages to filter by sport, sportsbook, game, or market. Omit filters and you get everything the plan allows.

Message types follow a clear pattern. initial_state delivers a snapshot of current odds on subscription. line_update fires on individual price changes. game_update sends all odds for a game when multiple lines shift. game_removed signals that an event ended or was suspended. Ping/pong keeps the connection alive.

Rate limits are 12 connections per minute per IP, with REST endpoints capped at 12 requests per minute (3-request burst). Those REST limits are tight. If you need to backfill or make frequent REST lookups, the constraints will bite. The WebSocket is clearly the intended data path, and the REST endpoints are better treated as reference lookups than primary data sources.

Separate WebSocket endpoints exist for play-by-play (/api/playbyplay) and live scores (/api/livescores). Play-by-play offers four streams with varying detail and latency, though the docs note that these endpoints are available to trial and custom users only.

Create an account on the BoltOdds sign-up page with an email and a password. The docs say the API key comes by email, so check your spam folder if it doesn't show up. The free trial lasts 3 days and includes almost all features. The pricing page says the trial button asks for a card and charges nothing if you cancel inside the 3 days (checked November 2026).

The key travels as the key query parameter, on the WebSocket URL and on every REST call. A URL with a key in it is easy to leak into logs, so keep all BoltOdds traffic on your backend. The docs warn against exposing the key in client-side code.

The sample calls GET /api/get_info, a plain REST call that lists what your key can subscribe to. The response holds two lists. sports carries league names such as UFC, Boxing and NBA. sportsbooks carries lowercase keys such as draftkings and neobet. The endpoint and fields are from the docs, checked November 2026.

import os

import requests

resp = requests.get(
    "https://spro.agency/api/get_info",
    params={"key": os.environ["BOLTODDS_API_KEY"]},
    timeout=30,
)
resp.raise_for_status()
info = resp.json()

print(len(info["sports"]), "sports:", ", ".join(info["sports"][:5]))
print(len(info["sportsbooks"]), "sportsbooks:", ", ".join(info["sportsbooks"][:5]))

Copy those strings exactly into your subscribe message. The docs say the API ignores filters in any other format, and a missing filter means all available options.

The docs list limits that the WebSocket section above doesn't cover. GET /api/snapshot and GET /api/odds/user each allow 6 requests a minute per IP. Snapshot also spends a token budget per key every 24 hours, and bigger requests cost more tokens. /api/odds/user reports your plan, open connections, subscriptions, and the snapshot fields daily_tokens, tokens_used and resets_at. Change filters on a live socket by sending a new subscribe message, but resubscribing too fast returns an error that asks you to wait 5 seconds. The docs say limits can change (checked November 2026).

The docs carry Python examples built on the websockets library and a troubleshooting section. They name no SDK, OpenAPI file, Postman collection, changelog or status page. Support is support@boltodds.com, a contact form on the site and a Discord server.

The WebSocket-first design and the SGP pricing engine point at specific builds:

• Parlay and SGP tools that need correlated same-game parlay prices from actual sportsbooks rather than independent-leg math.
• Live betting interfaces that display real-time odds with deeplinks, routing users to the sportsbook bet slip.
• Line-shopping widgets that stream prices from 40+ books, exchanges and prediction markets and highlight the best available number.
• Content and media apps that embed live odds alongside scores and play-by-play.

Skip it if you need sharp-book pricing (no Pinnacle), closing lines or futures markets, or historical data for backtesting below the Enterprise plan. Skip it too if your workflow is REST-heavy, since the 12-requests-per-minute REST cap is low and the product clearly steers you toward the WebSocket. Developers who need a polling-friendly REST API will be more comfortable elsewhere.

BoltOdds occupies a specific niche: WebSocket-native delivery with SGP pricing and deeplinks. Most odds APIs are REST-first and treat WebSocket as an add-on (sometimes a paid one). BoltOdds inverts that, which is an advantage if your architecture already consumes streams and a friction point if you expect a conventional REST workflow.

The book count (40+, counting exchanges and prediction markets) is moderate. The sport coverage is wide. The SGP pricing engine is rare. Those three facts define where BoltOdds fits: it is strong on delivery speed, sport breadth, and parlay tooling, and weak on sharp-book coverage, historical data, and REST ergonomics.

If sharp odds and closing lines are your priority, look at providers in the sports odds API directory that carry Pinnacle. If SGP pricing and WebSocket-native delivery are your priority, BoltOdds is one of the few APIs that treats both as first-class features.

BoltOdds is a focused product. The WebSocket stream works as advertised, the SGP pricing engine returns real correlated prices, and the deeplinks in every odds payload save you from building a URL-mapping layer. The 3-day trial is enough time to connect and test without spending anything.

The missing pieces are clear: no Pinnacle, no closing odds, no futures, and no historical archive below Enterprise. The Starter plan's one-league-one-market limit pushes most real projects to Growth or Pro. And the REST rate limits are restrictive enough that you should treat the WebSocket as the only serious data path. Test the trial, measure the latency, and confirm the sportsbook list covers your target markets before you commit a month.

Last updated: 2 November 2026 · How providers get listed