Sportsbook API 2026: Integration Guide for Major Sportsbooks
Access betting odds from DraftKings, FanDuel, BetMGM, Caesars, Pinnacle, Bet365 & 40+ more sportsbooks through direct and aggregated APIs.
Last updated:
What is a Sportsbook API?
A sportsbook API provides programmatic access to betting odds, lines, and markets from online sportsbooks. These APIs allow developers to integrate real-time betting data from major sportsbooks like DraftKings, FanDuel, BetMGM, Caesars, Pinnacle, Bet365, and many others into betting applications, odds comparison sites, and analytics platforms.
Sportsbook APIs come in two forms:
- Direct sportsbook APIs: Official APIs provided by the sportsbook itself (rare)
- Aggregated APIs: Third-party services that collect and distribute odds from multiple sportsbooks through a single API (most common)
Most developers use aggregated APIs because major US sportsbooks don't offer public APIs. Aggregator services collect odds from 40+ sportsbooks and provide unified access through one integration.
Compare Sportsbook API Providers
See which APIs cover DraftKings, FanDuel, BetMGM and other major sportsbooks.
Browse API Directory →Direct vs Aggregated Sportsbook APIs
Direct Sportsbook APIs
Official APIs from individual sportsbooks. Very few exist for public use. A handful of sharp sportsbooks offer direct API access, providing single-source data with low latency. These are useful for benchmarking closing lines and building models around sharp market odds.
Why most sportsbooks don't offer public APIs:
- Competitive advantage: They don't want odds comparison sites showing when competitors have better lines
- Legal restrictions: Licensing and regulatory concerns in different jurisdictions
- Scraping prevention: Protecting their platforms from unauthorized data collection
- Business model: They prefer customers place bets on their own site
Aggregated Sportsbook APIs
Third-party providers that collect odds from multiple sportsbooks and offer unified API access. This is the most common approach for developers building betting applications.
Advantages of Aggregated APIs
- One integration, 40+ sportsbooks: Access all major books through a single API
- Normalized data: Consistent formats across all sportsbooks
- Maintained infrastructure: Provider handles sportsbook changes and updates
- Legal compliance: No scraping or ToS violations
- Wide coverage: Get odds from books you don't have accounts with
Compare Sportsbook API Providers
Browse our directory to compare direct and aggregated sportsbook APIs side-by-side.
Browse API Directory →DraftKings, FanDuel, BetMGM and Caesars: API Status
None of these four US sportsbooks offers a public odds API that any developer can sign up for. BetMGM comes closest, with a documented API for approved business partners. This is where each book stands, as checked in October 2026.
| Sportsbook | Public API for developers | How developers get the odds |
|---|---|---|
| DraftKings | No public API | Third-party odds APIs that carry DraftKings lines. DraftKings runs an affiliate program for marketing partners, but an odds feed for affiliates is not documented publicly. |
| FanDuel | No public API | Third-party odds APIs that carry FanDuel lines. FanDuel runs an affiliate program (FanDuel Partners), but an odds feed for affiliates is not documented publicly. |
| BetMGM | Partner API only. The Sports API docs are public, but each partner needs BetMGM's approval. | Approved business partners pull fixtures, markets and prices from the BetMGM Sports API over REST. Everyone else uses third-party odds APIs. |
| Caesars | No public API documented. Caesars runs a developer portal, but it needs a login, and what it covers is not documented publicly. | Third-party odds APIs that carry Caesars lines. The public Caesars affiliate program lists casino and poker brands, and a sportsbook odds feed is not documented publicly. |
The JSON endpoints that a sportsbook's own website calls are not a public API. They are undocumented, they can change without notice, and using them can breach the book's terms of use. An aggregator does that maintenance for you and returns every book in one schema.
Coverage by Sportsbook
These are the major sportsbooks available through the APIs in our directory:
US Sportsbooks
- DraftKings: Available via most aggregator APIs
- FanDuel: Available via most aggregator APIs
- BetMGM: Available via most aggregator APIs
- Caesars: Available via most aggregator APIs
- PointsBet: Available via multiple aggregators
- Barstool: Available via multiple aggregators
- Pinnacle: Available via aggregators. Its own API closed to the general public in July 2025
- Circa Sports: No public API, available via some aggregators
- Bookmaker.eu: No public API. A few aggregators carry its moneylines, and specialist Bookmaker.eu APIs carry the full board, player props included
International Sportsbooks
- Bet365: Available via specialized aggregators focusing on international markets
- William Hill: Available via international-focused APIs
- Ladbrokes: Available via UK/European aggregators
- Betfair: Has exchange API, also aggregated
- 1xBet, 888sport, Unibet: Via international aggregators
Learn more about Bet365 API access →
Which Sportsbooks Should You Cover?
Focus on sportsbooks popular in your target market:
- US apps: DraftKings, FanDuel, BetMGM, Caesars, Pinnacle (for sharp lines)
- International apps: Bet365, William Hill, Pinnacle, regional books
- Odds comparison sites: As many as possible (10-40+ books)
- Sharp bettors: Pinnacle, Circa, Bookmaker.eu for closing line value
How to Choose a Sportsbook API Provider
1. Sportsbook Coverage
Verify the API covers sportsbooks your users actually use. Check the provider's sportsbook list: some focus on US markets, others on international books. The Coverage Map does that check for you, using our own test calls where we hold a key and the provider's docs where we don't.
2. Markets & Bet Types
Ensure the API provides the markets you need:
- Moneylines, spreads, totals (standard on all)
- Player props (premium feature)
- Same-game parlays (rare)
- Futures and outrights
- Alternative lines
3. Update Frequency
- Pregame: Hourly updates sufficient for basic comparison
- Line shopping: 5-15 minute updates
- Live betting: WebSocket or sub-second polling required
Learn more about live odds APIs →
4. Pricing
- Free tiers: 100-500 requests/month for testing
- Basic plans: $20-100/month for pregame odds
- Professional: $200-500/month for live odds, props, high volume
5. Additional Features
- Bet deeplinks: Direct links to place bets on sportsbooks
- Bet settlements: Automated result tracking
- Historical odds: Past lines for backtesting
- Stats integration: Combined odds and statistics
Sportsbook API Integration
"Sportsbook API integration" means two different projects, and the feed you need depends on which one you run. A site or an app that shows odds, such as a comparison tool, a model, a Discord bot or an affiliate page, consumes a feed. An operator integrates a feed into a platform that takes bets on it. The steps below cover the first project. What an operator integrates covers the second, and how to decide what to build and what to buy.
The first choice: direct or aggregated
A sportsbook API integration starts with one choice: a direct feed from one book, or an aggregated feed that carries many books in one schema. A direct feed suits a model built on one sharp book, and few books offer one (see direct vs aggregated above). An aggregated feed suits an odds screen, a line-shopping tool or a bet tracker, because one key covers the books that your users hold accounts with. Most teams pick an aggregator and then work through the nine steps below. The work is much the same with any provider.
The nine steps
- Get a key. Sign up for a free tier or a trial, and keep the key on your server. A key in browser code is a key that anyone can copy. Most providers read the key from a request header or a query parameter, so check the auth section of the docs first: a key in the wrong place returns a 401 and no other hint.
- Make a first request. List the sports or events, then pull the odds for one game and one market. Read the response headers too, because many providers report your remaining quota there.
- Map the odds formats. US books quote American odds (+150, -120), most of the world uses decimal odds (2.50, 1.83), and UK books often show fractional odds (3/2). Store one format, usually decimal, and convert for display: +150 and 3/2 are both 2.50, and -120 is about 1.83.
- Normalize the names. Each book spells a team, a league or a market its own way. An aggregator does most of this work, but check the join keys: a game id, a team id and a market key that stay the same across books and across days. Build one table that maps every provider name to your own id, and add a row the first time a new name appears. A string match on "LA Clippers" against "Los Angeles Clippers" breaks the first time a book changes its label.
- Choose polling or push. A poll every few minutes is enough for pre-match odds. Live odds need a WebSocket or another push feed, because polling fast enough uses more requests than most plans allow.
- Respect the rate limits and cache. Every plan caps requests per month, and most cap requests per minute as well. Read the quota headers on each response, and stop before the limit rather than after a 429. Cache each response for as long as the market allows: an hour for a futures price, a few minutes for a pre-match line, seconds for a live line. Check the plan's unit before you shape your calls: many providers charge per call whatever its size, so one league per call beats one game per call, and others charge a credit per market or per region, so a wide call costs more. A cache in front of your own app turns a hundred page views into one request.
- Store a timestamp per price. Keep the provider's last-update time next to every price, so that you can hide stale lines and rebuild line movement later.
- Settle bets and grade picks. A settlement step turns a price into a result. Most odds APIs return scores and final results through a separate endpoint, and some sell them as an add-on, so check that the plan covers results for the leagues that you need. Match each result to the market that you stored: a spread settles on the line that your user took, which can differ from the opening line. Keep the closing line as well, because closing line value is the first metric that a sharp user asks for.
- Plan the bet flow. A data API only reads prices, so your app cannot place a bet through it. The API has no access to the bettor's account, and regulated books require the bettor to sign in, pass identity and location checks, and confirm each bet in the book's own app. Deep links can send the user to the right bet slip.
Legal basics for a sportsbook API integration
An odds feed is data, and reading it breaks no betting law. The rules start when your app touches a bet. If the app places or brokers a wager, the operator needs a license in every state or country where a user bets. An odds screen with deep links to licensed books needs no betting license, but several US states require an affiliate who earns a fee from a book to register with the state regulator. Read the provider's terms as well: a plan can forbid resale of the raw data, a public display of a book's lines, or a use that the book has not approved. Your own terms should say where the data comes from and how old it can be.
How long a sportsbook API integration takes
A first odds screen takes a developer a day or two: a key, a cron job that polls one league, a table of prices and a page that reads it. A live odds screen with a push feed and a cache takes a week or two more. Settlement, line history and a name map across forty books take the most time, and they need upkeep, because books add markets and rename teams every season. Budget for the plan as well as the build: the request cap on a free tier covers a prototype and no more, so price the plan that your traffic needs before you ship.
The getting started guide shows a first request in code. Pick a provider in the directory, and check which books it carries on the Coverage Map before you write code.
What an operator integrates
An operator, a sportsbook or a fantasy product, integrates a feed into a platform that takes bets on it. It pulls in the components below, and builds or buys each one.
- Pre-match odds feed: fixtures with moneylines, spreads and totals per book, refreshed by polling every few minutes. Both projects start here.
- In-play odds feed: the same markets during the game, pushed over a WebSocket or another stream, because polling fast enough costs more requests than a plan allows. Suspension flags matter as much as prices. A market that a book has pulled must leave your screen within seconds.
- Results and settlement: final scores and per-market outcomes, so that bets settle without a person reading a box score. An operator needs a settlement feed it can trust. A comparison site can settle from a scores API.
- Player props and alternate lines: hundreds of markets per game, often a separate feed or a higher plan, with the same push-or-poll choice.
- Risk and trading: limits, margins, line movement and the sharp books' prices to lean on. An operator either employs traders who set its own lines or buys a managed trading service that sets them.
- Front end: odds widgets, bet slip deep links that open the right market in the book's app, and the odds-format conversion for each market you serve.
Build or buy
Building means licensing raw feeds from the books or from a data supplier, writing the normalization and the settlement logic, and staffing a trading desk. It fits an operator with a license and a margin to protect. Buying means an aggregated odds API for the data and, for an operator, a managed platform that bundles the feed, the trading and the front end, paid as a share of handle or a monthly fee. Most products that show odds, and most new operators, buy. The integration then takes weeks rather than a year, and the supplier carries the book-by-book maintenance.
Check the coverage before you sign
A feed is only as good as the books, leagues and markets it carries, and a sales deck rounds those numbers up. The Coverage Map records, for each odds API in our directory, which sportsbooks it returns, which leagues and which market families, with the date of each claim, verified by our own test calls or taken from the provider's docs. Filter it by the books your users bet with and the leagues you need. Then read the live odds guide for what in-play latency looks like in practice.
Questions to settle in the contract
- Which use the license covers: display to the public, internal models, or operator use that takes bets on the prices.
- The update cadence per market, and whether live markets arrive by push or by poll.
- Whose ids you map to. Each feed names teams, players and markets its own way, so budget for the mapping layer.
- The settlement source of truth, and what happens when a result changes after the fact.
- Failover: what your app shows when the feed stalls, and how you find out.
Compare the aggregated and direct APIs in the API directory, filtered by live odds, player props and streaming, and test one on its free tier before you sign.
Odds APIs by Sportsbook
Each sportsbook below has its own page: whether the book offers an official API, how hard it is to scrape, and every odds API in our Coverage Map that carries it, with the source and date of each claim. The number is how many odds APIs carry the book.
- DraftKings odds API 23 APIs
- Kalshi odds API 22 APIs
- Bovada odds API 20 APIs
- FanDuel odds API 20 APIs
- BetMGM odds API 19 APIs
- BetRivers odds API 19 APIs
- Bet365 odds API 18 APIs
- BetOnline odds API 18 APIs
- Novig odds API 18 APIs
- Pinnacle odds API 18 APIs
- theScore Bet odds API 18 APIs
- Fanatics Sportsbook odds API 17 APIs
- Caesars Sportsbook odds API 16 APIs
- Hard Rock Bet odds API 16 APIs
- ProphetX odds API 16 APIs
- Circa odds API 14 APIs
- Betfair Exchange odds API 12 APIs
Frequently Asked Questions
Ready to Integrate Sportsbook Data?
Compare aggregated API providers covering DraftKings, FanDuel, BetMGM, Pinnacle, Bet365 and 40+ more sportsbooks.