12 min readIntegrate odds feeds into your sportsbook: normalization across providers, XML and JSON feeds, real-time updates and risk controls. Talk to engineers.
Planning an odds feed integration?
Talk to our sportsbook engineering team before you sign with a provider.
A few minutes after the 3 o'clock kick-offs one Saturday, a trader on a platform we'd been asked to help started suspending football markets by hand. Monitoring was green. The feed connection was up. It simply hadn't delivered a price in about forty seconds, and nothing in the stack was built to notice.
We've seen versions of that afternoon many times since. The provider is rarely the part that fails. The integration is: one shared pipe for everything, no heartbeat check, and no way to recover what was missed during a reconnect.
The one-paragraph version: odds feed integration means taking fixtures, prices, results and trading signals from a data provider, mapping them into your platform's own model, and getting updated prices in front of bettors within a few hundred milliseconds, while refusing to show any price you can't stand behind. When it's done well nobody talks about it. When it isn't, you lose margin to arbitrage players a little at a time, often for weeks before anyone connects the dots.
What follows is the architecture we use when we connect a sports odds API to a production sportsbook, including a few things we got wrong the first time. It's the first of four posts on sportsbook architecture; if you're earlier in the journey and still costing the whole platform, our guide to building an online casino platform in 2026 is a better place to start.
1. What a live odds feed actually sends you
A betting odds feed arrives as four kinds of data, and they behave differently enough that each needs its own handling. Sportradar, Genius Sports and the smaller specialists all package them their own way, but underneath the split looks like this:
| Stream | What's in it | Typical volume | How fast it matters |
|---|---|---|---|
| Fixtures (reference data) | Sports, competitions, teams, players, venues | Kilobytes a day | Minutes are fine |
| Odds and prices | Pre-match and in-play prices per market and selection | Thousands of messages a second on a big football slate | Every millisecond counts in-play |
| Results and scoring | Goals, cards, sets, final results | Bursty around live events | Seconds; drives trading and settlement |
| Trading signals | Suspensions, cancellations, voids from the provider's own traders | Low, but critical | Immediately |
On new builds, the most common early mistake is pushing all four through one consumer and one queue. It's simpler to draw and to demo. Then, in production, a burst of in-play price updates sits in front of a void message, and for a second or two you're accepting bets on a market the provider has already cancelled.
So we split ingestion by stream from the first sprint. It's a little more plumbing up front, and it removes a whole class of incident.
2. Transport: how the sportsbook odds API reaches you, and what sits behind it
Official feeds push updates over a persistent connection. Sportradar's Unified Odds Feed, for example, is delivered over AMQP with XML messages; other providers use WebSocket or long-lived HTTP push, often with JSON. Reference data and some slow-moving markets still tend to come from REST endpoints you poll.
We treat all of that as a detail of the edge. Each provider gets a small ingestion gateway that authenticates, checks message sequence numbers, and publishes raw messages to one internal backbone. Nothing past the gateway knows or cares which protocol the data arrived on. If that sounds familiar from the casino side, it should: it's the same problem we solved when we put 2,000+ games behind a single API in our slot aggregator case study, where every studio also had its own formats and quirks.
Our backbone of choice is Apache Kafka, for three practical reasons.
It keeps per-match order where it matters. Key raw records such as those on odds-raw-sportradar by event ID, and every update for one match lands on the same partition while different matches run in parallel. Two caveats people miss. Kafka only preserves the order the gateway publishes in, so if the gateway reconnects and receives messages out of sequence, Kafka will faithfully store them out of sequence; that's why the gateway checks the provider's sequence numbers first. And the producer itself can reorder records when it retries a failed send unless idempotence is switched on:
# Gateway producer: keep per-event order even when sends are retried
enable.idempotence=true
acks=all
max.in.flight.requests.per.connection=5 # safe with idempotence on
# key every record by the provider's event ID
Keying by event also means a Champions League final or a Grand Slam final puts far more traffic on one partition than an average fixture. Size partitions and consumers for the biggest match on your calendar, not the average one.
Kafka also lets consumers move at their own speed. Normalization, the risk engine and the front-end fan-out each have their own consumer group, so a slow reporting job can't delay the price a customer sees. And it gives you replay: after an incident you can rewind a topic and reprocess exactly what came in, which has settled more post-mortem arguments for us than any dashboard. The same event-driven setup runs the real-time pipelines on our Kafka development page; an odds feed is just the one with the tightest deadlines.
3. Odds normalization and market mapping
Every provider has its own IDs, its own names for markets and its own way of saying "match postponed." Normalization turns all of that into one canonical model, usually three levels deep:
- Event: the fixture, with your own ID, start time, status and team IDs from a master mapping table.
- Market: the bettable question, such as match result (1X2) or total goals over/under 2.5, with its type, period, line and a revision number.
- Selection: each outcome a customer can pick, such as Home, Draw or Away, with its decimal price and status.
The mapping tables deserve the same care as code. Providers add market types regularly, and an ID that doesn't map rarely throws an error; the market just never appears on your site. We alert on every unmapped provider market ID and go through the list weekly with the trading team, because they know which gaps actually cost money.
Price validation belongs here too, right at the point of entry. Some checks are absolute: a decimal price at or below 1.00, a price for a selection that has already settled, or a complete market whose implied probabilities add up to less than 100% (the provider would be handing out free money). Those go to a dead-letter topic for a trader to look at. Only run the margin check on complete markets; a market with a suspended selection will look under-round for perfectly innocent reasons.
Large price jumps need more judgement. A 40% move in one tick before kick-off is almost certainly bad data. The same move a second after a goal or a red card is exactly what should happen. So our jump check only holds a price when no matching score or status event arrived just before it. Without that condition, you end up blocking the moments bettors care about most.
4. Serving real-time sports odds to the customer's screen
Normalized prices go into a hot cache, usually Redis, keyed by event and market. Each write carries the market's revision number so a late, older update can't overwrite a newer one. That check has to be atomic: if one call reads the revision and another writes the price, two workers under load will eventually interleave and the older price wins. We do both in a single Lua script:
-- KEYS[1] = market key, ARGV[1] = incoming revision, ARGV[2] = market payload
local current = tonumber(redis.call('HGET', KEYS[1], 'rev') or '0')
if tonumber(ARGV[1]) <= current then
return 0 -- stale or duplicate update, ignore it
end
redis.call('HSET', KEYS[1], 'rev', ARGV[1], 'data', ARGV[2])
return 1
The front end never polls the core. A fan-out service subscribes to the normalized stream and pushes only what changed to connected clients over WebSocket or server-sent events, through an edge gateway. When a mobile network blips and fifty thousand clients reconnect at once, that load stays at the edge instead of reaching the services that price and accept bets. On reconnect, each client sends the last revision it saw per market and gets a snapshot of anything newer before the deltas resume, so nobody sits looking at a price from before they went into a tunnel.
This fan-out pattern isn't unique to sportsbooks. The same approach streams the live multiplier in crash games, and our crash game API integration guide covers that side in more detail.
On latency, measure from the moment a message reaches your gateway, since provider-side delay isn't yours to control. From there to a visible price, 150 to 300 milliseconds is a sensible in-play target; pre-match can live with one to two seconds. In-play books also add a short bet acceptance delay, commonly a few seconds, so a price the bettor clicked can be checked against anything that happened in the meantime. The faster your feed path, the shorter that delay can safely be.
Track each hop separately: gateway lag, normalization lag, fan-out lag. A complaint that "the odds feel slow" gives an engineer nothing to work with. A graph showing tennis normalization lag climbing from 20 to 400 ms at 14:02 usually points straight at the cause.
5. Failover, staleness and knowing when to suspend
At some point a feed will drop in the middle of a match. What matters is whether your platform reacts on purpose or by accident.
Detect staleness from the provider's heartbeat, not from market activity. A healthy in-play market can go several seconds without a price change, so timing out on market silence suspends perfectly good markets. Most official feeds send regular alive or heartbeat messages per producer (live odds, pre-match and so on). When those stop for longer than your agreed threshold, suspend every market from that producer at once. An open but silent connection looks exactly like a working one unless you check for this.
Recover before you reopen. After a reconnect, sequence and revision numbers tell you what you missed. Request the provider's recovery snapshot, apply it, and only then reopen markets. Reopening on prices from before the gap is how operators end up paying out on odds that were already dead.
Be careful with automatic failover to a second provider. The backup will price the same match differently and won't carry every market, so a live switch causes visible price jumps and some markets disappear. The pattern we trust is simpler: suspend when the primary fails, then reopen on the backup only for markets mapped on both feeds, with the trading desk able to hold anything they're unsure of. Finally, put a circuit breaker on each provider. If its error rate spikes or messages fail validation in bulk, stop consuming it altogether rather than half-processing corrupted data.
All of these thresholds are trading decisions as much as engineering ones. Agree them with the trading team in writing before launch, so nobody is inventing them during the first outage.
6. Four failure modes we keep seeing
Most of the post-launch incidents we're asked to look at fall into one of four patterns.
Arbitrage windows. Your prices trail the market by a second or two and sharp accounts back the stale side. A faster price path is half the fix. The other half is exposure limits per market in the risk module, which part two of this series, on sportsbook risk management, covers.
Void storms. After a data correction, a provider can send hundreds of cancel and void messages in a few seconds. Services written on the assumption that each message arrives once and in order end up in a corrupted state. Give voids their own handling, and test them with a replayed storm before launch; the settlement side of this is in part three, on bet settlement engine design.
Clock skew. Many in-play settlement disputes come down to a bet accepted a few hundred milliseconds after the provider recorded a goal. Store two timestamps on every bet: your acceptance time and the provider's event time. They're only useful if your servers agree on the time, so run NTP (or PTP where you need tighter accuracy) on every node that accepts bets, and alert on drift.
Backpressure. A heavy reporting or analytics job reading the same topics as your live services can slow them down if they share a consumer group. Keep separate consumer groups for separate jobs, and keep analytics off the pricing path entirely.
7. Choosing a sports betting API provider: what to ask before you sign
Sports odds APIs serve quite different buyers. Low-cost aggregator APIs that collect prices from other bookmakers work well for comparison sites and affiliate tools. A licensed sportsbook trading its own book needs an official, contracted feed with in-play coverage, trading signals, a recovery mechanism and an SLA. If you're launching on a white-label platform, the feed usually comes bundled, and the questions below become questions for the platform vendor; our white-label iGaming platform case study shows what that trade-off looks like in practice.
Before any odds provider integration, get clear answers to these:
- Coverage: which sports, leagues and markets are included in-play, not just pre-match?
- Delivery: push or poll, which protocol, and what's the documented latency from event to message?
- Recovery: can you request a full snapshot after a disconnect, and do messages carry sequence or revision numbers?
- Market taxonomy: how often do new market types appear, and are changes announced before they go live?
- Licensing: is the data official for the leagues you care about, and approved in the jurisdictions you hold licences in? Rules differ a lot between markets such as Germany, Spain, Brazil and Canada; our GGL-ready German casino platform case study shows how much a single regulator shapes the build.
- Test environment: is there a sandbox with recorded live traffic, so you can load-test before launch?
Of these, weigh the recovery answer most heavily. Gaps in coverage or taxonomy can be worked around with a second provider or extra mapping. A feed with no clean way to recover after a disconnect leaves you guessing about prices every time the connection drops.
What to take away
Good odds feed integration isn't a secret. The patterns are well known; the hard part is getting all of them in place and keeping them there as providers, markets and traffic change. The platforms that trade calmly through peak weekends tend to share the same habits: separate streams, one canonical model, validation that understands in-play context, heartbeat-based staleness, recovery before reopening, and a metric on every hop.
For a live sports product we've shipped, see the Scorex live sports app case study. And if you're planning a new build or untangling an integration that's grown messy, our sportsbook software development services team designs and runs these pipelines end to end, from the provider contract to the WebSocket edge, for fiat and crypto sportsbooks alike. Send us a description of your current setup and we'll tell you honestly where we think it will break first.
Frequently asked questions
What is odds feed integration?
It's the work of connecting a sportsbook to a live odds data provider: receiving fixtures, prices, results and trading signals, mapping them into the platform's own model, and getting updated prices to bettors in real time, with safeguards against stale or bad data.
How many odds providers should a sportsbook use?
Most regulated operators run one primary feed for breadth of coverage and a second provider as a fallback on their biggest sports. Two full feeds everywhere rarely pays for the extra mapping work. Put dual coverage where your turnover is, usually football, tennis and basketball.
How are live odds delivered: AMQP, WebSocket or REST?
Official feeds push live odds over a persistent connection. Sportradar's Unified Odds Feed uses AMQP; other providers use WebSocket or HTTP push. REST polling is normally kept for reference data and slow-moving pre-match markets, because polling live prices wastes rate limits and adds latency.
Why put Kafka between the odds feed and the application?
Kafka separates how fast data arrives from how fast each service reads it. With records keyed by event and an idempotent producer, it keeps each match's updates in order, lets risk, trading and the front end read the same stream independently, and lets you replay data after an incident.
What is a good latency for live odds?
Measured from when a message reaches your gateway to when the price appears on screen, 150 to 300 milliseconds is a realistic in-play target. Pre-match markets can tolerate one to two seconds. In-play bets usually also pass through a short acceptance delay of a few seconds.
How do you detect a stale odds feed?
Watch the provider's heartbeat or alive messages for each producer, not the time since a market last changed. If heartbeats stop for longer than an agreed threshold, suspend that producer's markets, request a recovery snapshot on reconnect, and reopen only once it has been applied.
How do you test an odds feed integration before launch?
Replay recorded provider traffic at accelerated speed, inject silence and corrupted messages, and cut the primary feed mid-test to prove failover works. Then check that downstream balances and bet states match before and after the replay.
XML Odds Feeds: Parsing and Integration
\nMany official providers still deliver data over AMQP as XML documents. Sportradar's Unified Odds Feed is the most common example in regulated markets. An XML odds feed typically wraps each update in a typed envelope — a sport, a fixture, a market update, or a trading signal — and carries a message type and sequence number in attributes. Your ingestion gateway parses the XML, extracts the relevant fields, validates the sequence number, and publishes a normalized JSON record to your internal Kafka topic. The raw XML format is a concern of the gateway only; nothing downstream should ever see it. This also means switching from an XML odds feed to a JSON-based provider later is a gateway configuration change, not a platform rewrite. For the full ingestion and normalization pipeline, see our casino and sportsbook development services.
\nRisk Management Controls for Odds Feed Pipelines
\nAn odds feed that works technically is not the same as one that doesn't lose money. Risk controls sit inside the normalized stream, not the raw one, so they see clean prices in your canonical model. The most important are: per-market exposure limits that suspend a market automatically when liability crosses a threshold, jump filters that hold any price change above a configurable percentage unless a correlated score event justifies it, and a dead-letter topic with trader review for any message the automated checks reject. Read the full architecture in part two of this series on sportsbook risk management, and see how our sportsbook development team designs these controls for production operators.
\nRelated Services from Betadrix
At Betadrix, we specialize in delivering enterprise-grade solutions. Explore our related services to see how we can assist with your technology goals: React Native App Development Company | Betadrix, Casino & Sportsbook Software Development Company in Germany, Casino Game Development Services | Betadrix, Casino, Sportsbook & Gaming Software Development Company in Spain, Custom Software Development Company | Offshore Teams, Jaipur, Casino & Sportsbook Development Services in Finland, Casino Sportsbook Development Services | Betadrix, Custom Crash Game Development | Aviator-Style Platforms | Betadrix, Casino & Sportsbook Development Services in Austria | Betadrix, Casino & Sportsbook Software Development Company in Canada, B2B Casino, Sportsbook & Blockchain iGaming Platform Development in Brazil, Crypto Casino Software Development Company | Betadrix.
Need a second opinion on your feed architecture?
We review transport, normalization and failover design for live sportsbooks.
Key components of sports odds feed integration architecture
Multi-stream feed ingestion
Segregating fixtures, prices, results and trading signals into dedicated pipelines to eliminate message blocking.
Ingestion gateway & Kafka backbone
Edge gateway checking sequence numbers and publishing to event-keyed, idempotent Apache Kafka partitions.
Odds normalization & market mapping
Standardizing provider taxonomies into canonical events, markets and selections with entry-level margin validation.
Hot cache & WebSocket fan-out
Atomic Redis revision checking via Lua scripts paired with edge WebSocket gateways pushing deltas to connected clients.
Heartbeat staleness & failover safeguards
Producer heartbeat tracking, recovery snapshot synchronization, and circuit breakers preventing stale pricing.
Sportsbook platform engineering
Custom sportsbook odds feed integration and high-throughput real-time betting architectures by Betadrix.
Ready to build your sportsbook?
Get a scoped plan for odds integration, risk management and settlement.
Related Services
Series Guide
iGaming & Casino Gaming
Explore Categories
Browse More Technical Topics & Industry Guides
?Frequently Asked Questions
What is odds feed integration?
How many odds providers should a sportsbook use?
How are live odds delivered: AMQP, WebSocket or REST?
Why put Kafka between the odds feed and the application?
What is a good latency for live odds?
How do you detect a stale odds feed?
How do you test an odds feed integration before launch?

Shivam Swami
Founder & CEOShivam Swami is the Founder & CEO of Betadrix, leading technical architecture and engineering. He specializes in distributed systems, real-time betting architectures, and high-concurrency iGaming platforms.
Build Your Custom Project
Connect with technical architects for scope and estimation.
More Articles in iGaming & Casino Gaming
Related services built to solve your specific challenges
Watch.
Learn.
Grow.
Discover how our engineered solutions transform industries and propel client operations forward.

Owning the Game, Not Renting It: Custom Crash Game Development for a Lahore-Based iGaming Operator
READ CASE STUDYTechnologies & Frameworks Powering This Service
Hire Specialized Developers For Your Service Project

Flutter Developers
Pre-vetted senior Flutter Developers ready to deploy into your existing architecture in 3-7 days.

Nodejs Developers
Pre-vetted senior Nodejs Developers ready to deploy into your existing architecture in 3-7 days.

React Developers
Pre-vetted senior React Developers ready to deploy into your existing architecture in 3-7 days.

Python Developers
Pre-vetted senior Python Developers ready to deploy into your existing architecture in 3-7 days.
What Our Clients Say
“Mobile app development and cloud migration were handled smoothly. Strong technical skills, clear communication, and dependable post-launch support stood out throughout the engagement.”

Sarah Mitchell
Director of Operations, HealthFirst Clinics
Have a Project in Mind?
Let's Build It Together.
Connect directly with our senior software architects and technical leads. We evaluate your requirements and deliver an actionable technical proposal within 24 hours.
Strict NDA Protection
Your intellectual property and technical specs remain 100% confidential.
24-Hour Response Guarantee
Guaranteed evaluation and scoping reply from an engineering manager.
Zero Obligation Estimate
Get accurate cost breakdowns and tech stack recommendations free of charge.
Request Free Technical Consultation
Let's build something serious.
Diagnose your system architecture, budget ranges, and roadmap parameters with an expert.
Scoping Diagnostic
Analyze your workflows in 60 seconds. A senior AI architect reviews every parameter personally.
Not sure where AI actually moves the needle for you?
Answer a few brief questions. We will deliver a highly concrete scoping plan within 24 hours including:
- Recommendations on automation use-cases and MVP components
- Calculations on expected ROI and engineering timelines
- A structural roadmap to make your legacy stack AI-native











