Arbitrage Odds API
Sure Bets API Data for Arbs
Arbitrage APIs explained: signals, structure, and what they return
An arbitrage API (also called a sure bet API) is an HTTP endpoint that returns pre-identified two-sided betting opportunities where placing bets on all outcomes of an event across multiple bookmakers guarantees a profit regardless of the result.
The maths: if Bookmaker A offers 2.10 on Team X to win, and Bookmaker B offers 2.10 on Team X to lose (or draw), the combined implied probability is below 100%, meaning a guaranteed profit exists. The API provider continuously scans 40–200+ bookmakers to find these discrepancies and delivers them as structured JSON — the event, both bookmakers, both odds, the ROI percentage, and recommended stake allocation.
The three dedicated arbitrage API providers available to independent developers are OddsJam, BetBurger, and RebelBetting. All three scan both pre-match and live markets. BetBurger has the widest EU/global bookmaker coverage; OddsJam has the strongest US coverage; RebelBetting's API is available only through a custom engagement.
How arbitrage APIs work: opportunity detection and two-leg logic
Every arbitrage API follows the same detection loop:
1. Continuous multi-book odds ingestion
The provider maintains connections to 40–200+ bookmakers via their own feed infrastructure — direct API integrations where available, headless browser scraping with MutationObserver otherwise. Odds are normalised to decimal format and mapped to canonical event and market IDs to enable cross-book comparison.
2. Implied probability aggregation
For each event/market combination, the system holds the current best odds from every monitored book. It computes the implied probability for each outcome across all books, then sums the minimum implied probability across outcomes. When the sum drops below 100%, an arbitrage opportunity exists.
3. ROI and stake calculation
ROI = (1 / sum of minimum implied probabilities) - 1. For a two-outcome event with odds of 2.10 and 2.10: ROI = (1 / (1/2.10 + 1/2.10)) - 1 = (1 / 0.952) - 1 = 5%. The API returns both the ROI and the recommended stake split to guarantee equal profit regardless of which outcome wins.
4. Delivery with latency context
The opportunity is delivered via the API with a timestamp indicating when it was first detected. BetBurger's API includes the opportunity's age in seconds — a critical field for filtering out stale arbs that may have already closed at the bookmaker before you can execute.
| Arb type | Typical ROI | Persistence | Books involved |
|---|---|---|---|
| Pre-match (soft vs soft) | 1–3% | 1–10 minutes | Two soft books |
| Pre-match (sharp vs soft) | 1–2% | 30 sec–3 min | Pinnacle / sharp + soft |
| Live in-play | 2–8% | 5–30 seconds | Any two books |
| Prediction market cross-venue | 2–15% | Minutes–hours | Kalshi, Polymarket, Sportmarket |
OddsJam vs BetBurger vs RebelBetting: arbitrage API comparison
| Platform | API Access Model | Required Plan | Cost | Coverage Focus | Live Arb |
|---|---|---|---|---|---|
| OddsJam | Self-serve (dashboard) | Gold plan | $99/mo | US/Canada, 80+ books | Yes |
| BetBurger | Self-serve token (/profile/api) | Combined (Prematch + Live) | €319.99/mo | EU/Global, 65+ books | Yes |
| RebelBetting | Custom Solutions (sales) | Custom contract | Negotiated | EU/UK, 90+ books | Yes |
OddsJam arbitrage API
OddsJam's Gold plan ($99/month) includes both +EV and arbitrage ("sure bet") API endpoints. The arbitrage endpoint returns current opportunities across US sportsbooks — DraftKings, FanDuel, BetMGM, Caesars, ESPN BET, and 75+ more — with ROI, both bookmaker slugs, both odds, the event, and the market type. Authentication is via API key from the account dashboard.
Best for: US and Canadian bettors who want the lowest-cost self-service arb API entry point with immediate activation. The $99/month Gold plan covers both arb and +EV endpoints in a single subscription.
Coverage note: OddsJam's strength is the US market. International bookmaker coverage (EU, UK, Asian books) is limited compared to BetBurger. If your bookmaker accounts are primarily at US-regulated sportsbooks, OddsJam's API is the most practical choice.
BetBurger arbitrage API
BetBurger's API delivers the same sure bet signals as their web scanner via two separate REST endpoints: one for pre-match, one for live. API access requires an active Combined subscription (€319.99/month) plus a token requested from /profile/api. The pre-match endpoint can be polled every 30–60 seconds; the live endpoint every 5–10 seconds. Up to 1,800 results per minute across both.
The response includes the age of each opportunity in seconds — use this field to skip arbs that were detected more than 60 seconds ago (pre-match) or 10 seconds ago (live). Stale arbs are the leading cause of failed executions in automated arb pipelines.
Best for: EU/international arbers who need maximum global bookmaker coverage (65+ active books, 230+ with regional clones). If your bookmaker accounts span European, Asian, and African books, BetBurger's coverage depth justifies the higher subscription price.
Plan note: The Prematch-only subscription (€79.99/month) provides API access to pre-match arbs only. For live arb API access, the Combined subscription is required.
RebelBetting arbitrage API
RebelBetting's API is not available as a self-service product. Access is through their Custom Solutions programme — a bespoke arrangement suited to commercial operators, white-label developers, or high-volume institutional users. Their sure betting engine covers 90+ EU and international bookmakers.
Best for: Teams building commercial betting products that need EU/UK soft-book coverage as part of a licensed data contract. Individual developers who need immediate self-service access should use OddsJam or BetBurger first.
Which plan unlocks arbitrage API access
| Platform | Pre-match Arb API | Live Arb API | Cost | Activation |
|---|---|---|---|---|
| OddsJam | Gold plan | Gold plan | $99/mo | Self-serve — API key in dashboard |
| BetBurger | Prematch subscription + API token | Combined subscription + API token | €79.99/mo (prematch) or €319.99/mo (combined) | Request token at betburger.com/profile/api |
| RebelBetting | Custom Solutions | Custom Solutions | Negotiated | Contact rebelbetting.com/custom-solutions |
What an arbitrage API response looks like
While exact field names vary by provider, a typical arbitrage API response object contains:
{
"id": "arb_20240608_12345",
"event_name": "Arsenal vs Chelsea",
"sport": "soccer",
"league": "Premier League",
"starts_at": "2026-06-09T14:00:00Z",
"market": "match_result",
"age_seconds": 8,
"roi_percent": 2.4,
"legs": [
{
"bookmaker": "bet365",
"outcome": "home",
"odds": 2.65,
"stake_pct": 49.1
},
{
"bookmaker": "pinnacle",
"outcome": "away_draw",
"odds": 2.58,
"stake_pct": 50.9
}
]
}Key fields to use in your pipeline:
- age_seconds: filter out arbs older than your execution latency budget
- roi_percent: your minimum edge filter
- legs[].bookmaker: check against your active account list before attempting execution
- legs[].stake_pct: use the provider's pre-calculated stake split to avoid calculation errors
- starts_at: enforce a maximum time-to-event filter for pre-match
Wiring an arbitrage API pipeline: step-by-step
-
Poll both endpoints
Poll the pre-match arb endpoint and the live arb endpoint on separate schedules — pre-match every 30–60 seconds, live every 5–10 seconds. Store a deduplicated set of processed arb IDs in memory to avoid acting on the same opportunity twice.
-
Translate API format to bet-slip submission
The arbitrage API returns bookmaker slugs, decimal odds, and stake percentages. Before execution you must translate these into the exact bet-slip format each sportsbook or broker API expects: convert decimal odds to the platform's native format (American, fractional, or decimal), map the canonical bookmaker slug to the platform's market ID, and construct the bet object with the correct stake currency and rounding. A format-translation layer between your signal parser and your execution clients prevents the most common silent execution failures.
-
Parse and filter
Each arb object contains: event identifiers, both bookmakers (slugs), both odds (decimal), the ROI %, market type, and a timestamp. Filter by: minimum ROI (e.g. 1.5%), sport whitelist, bookmaker whitelist, maximum time-to-event (e.g. 4h for pre-match), and whether you hold accounts at both required books.
-
Calculate stakes
For a two-outcome arb: stake on Leg B = (stake on Leg A × Leg A odds) / Leg B odds. For a three-outcome arb (1X2 soccer): allocate proportionally to make guaranteed profit equal across all outcomes. Many arb APIs return pre-calculated stake ratios in the response — use them to verify your own calculation.
-
Place both legs fast
For pre-match arbs, you typically have 30–180 seconds. For live arbs, 5–15 seconds. Place Leg A first (the sharper book or the one less likely to change), then Leg B immediately. Log the odds you actually received — arb opportunities frequently have price slippage on one leg, which can turn a guaranteed profit into a loss.
-
Log and reconcile
Record: event ID, both bookmaker slugs, odds offered vs odds received, stakes, expected profit, and execution timestamp. At settlement, record the actual P&L per arb. Any arb with a negative P&L was subject to slippage, suspension, or an execution error — track these to improve your execution discipline.
Execution sportsbooks for automated arbitrage betting
Arbitrage requires accounts at both bookmakers in each opportunity. Your execution setup determines which arbs you can actually act on.
Both legs at soft books (manual)
Most pre-match arbs involve two soft bookmakers. Both legs must be placed manually and quickly — within the persistence window of the opportunity. Use the direct links returned by the API to navigate immediately to each bookmaker's bet page. Execute the larger-stake leg first (typically the one at the book with worse odds).
Sharp broker (Leg A) + soft book (Leg B)
Many arbs pair a sharp book (Pinnacle, SportMarket, BetInAsia) against a soft book. The sharp-side leg can often be placed via broker API (MadMarket, SportMarket) automatically; the soft-side leg is placed manually. This hybrid approach is the most practical for bettors using OpenClaw — the Skill File automates the broker leg while you handle the soft leg from the notification.
Prediction market cross-venue arb
Kalshi vs Polymarket vs Sportmarket cross-venue arbs are among the most automatable opportunities. Claw Arbs has all three pre-installed and can execute both legs automatically via their respective APIs and WebSocket feeds. Prediction market arbs tend to be larger (2–15% ROI) and persist longer (minutes to hours) than traditional sportsbook arbs, making them ideal for automated pipelines.
Arb API vs using a manual scanner UI — when the API wins
| Scenario | Manual Scanner | API Pipeline |
|---|---|---|
| Fewer than 20 bets/day | ✓ Sufficient | Over-engineered |
| 20–100 bets/day | Manageable with discipline | ✓ Meaningful advantage |
| 100+ bets/day | Not scalable | ✓ Required |
| Live in-play arbing | Very difficult | ✓ Near-essential |
| Notification while away from desk | Impossible | ✓ Telegram/Discord alerts |
| Custom sport/book filters | Limited by UI options | ✓ Any programmable condition |
| CLV and performance tracking | Manual spreadsheet | ✓ Automated database logging |
The break-even point is usually around 30–50 bets per day. Below that, the UI scanner is faster to get started and sufficient for the volume. Above that, the time saved on filtering, notifications, and logging makes the API investment worthwhile.
Sample Python workflow: BetBurger arb API → two-leg execution alert
import os, requests, time
BETBURGER_TOKEN = os.environ["BETBURGER_API_TOKEN"]
TELEGRAM_BOT_KEY = os.environ["TELEGRAM_BOT_TOKEN"]
TELEGRAM_CHAT_ID = os.environ["TELEGRAM_CHAT_ID"]
MY_BOOKS = {"bet365", "william_hill", "unibet", "pinnacle", "betinasia"}
MIN_ROI = 0.015 # 1.5% minimum guaranteed profit
MAX_AGE = 45 # skip arbs older than 45 seconds
def fetch_arbs():
url = "https://rest-api-pr.betburger.com/api/v1/arbs/api_bots_meta"
r = requests.get(
url,
headers={"Authorization": f"Bearer {BETBURGER_TOKEN}"},
params={"per_page": 30, "min_roi": MIN_ROI * 100},
timeout=10)
r.raise_for_status()
return r.json().get("bets", [])
def is_actionable(arb):
if arb.get("age_seconds", 999) > MAX_AGE:
return False
books = {leg["bookmaker_name"].lower() for leg in arb.get("legs", [])}
return books.issubset(MY_BOOKS)
def format_alert(arb):
roi = arb["roi"] / 100
legs = arb.get("legs", [])
lines = [f"*ARB ALERT* — ROI {roi:.1%}",
f"Event: {arb['event_name']}",
f"Market: {arb['market']}",
f"Age: {arb.get('age_seconds')}s"]
for leg in legs:
lines.append(
f" Leg: {leg['bookmaker_name']} @ {leg['odd']} "
f"(stake {leg['stake_percent']:.1f}%) — {leg.get('direct_link','')}")
return "\n".join(lines)
def send_telegram(text):
requests.post(
f"https://api.telegram.org/bot{TELEGRAM_BOT_KEY}/sendMessage",
json={"chat_id": TELEGRAM_CHAT_ID, "text": text, "parse_mode": "Markdown"})
def main():
seen = set()
while True:
for arb in fetch_arbs():
arb_id = arb.get("id")
if arb_id in seen:
continue
seen.add(arb_id)
if is_actionable(arb):
send_telegram(format_alert(arb))
time.sleep(30)
if __name__ == "__main__":
main()
This pipeline polls the BetBurger pre-match arb endpoint every 30 seconds, filters for actionable opportunities (fresh, at books where you hold accounts), and fires a Telegram message with both legs formatted for immediate manual execution. Extend it by: adding the live endpoint on a 10-second loop, implementing broker-side automated execution for the sharp leg, and writing every arb to a database for post-settlement P&L analysis.
Arbitrage Automated Betting API Questions & Answers
What is an arbitrage API in sports betting?
An arbitrage API returns pre-identified opportunities where betting on all outcomes of an event across multiple bookmakers guarantees profit regardless of the result. The API provider continuously monitors odds across 40–200+ bookmakers, detects when the combined implied probability drops below 100%, calculates the ROI, and returns the opportunity as a structured JSON object. You receive the signal; you execute the bet.
What is the minimum ROI to filter arbitrage API results?
Most experienced arbers filter at 1.5–2% minimum ROI on pre-match and 2.5–4% on live in-play. Setting the minimum too low (under 1%) produces many opportunities where execution slippage eliminates the profit. Setting it too high (over 5%) produces very few opportunities. A 2% filter with fast execution and direct bookmaker links is the practical starting point for most automated arb pipelines.
Which BetBurger plan gives access to the arbitrage API?
BetBurger API access requires an active subscription — Prematch (€79.99/month) for pre-match arbs only, or Combined (€319.99/month) for both prematch and live. You also need to request an API token separately from your account at /profile/api. The API returns the same sure bet signals as the web scanner, in JSON format, at up to 1,800 results per minute.
Does OddsJam have an arbitrage API?
Yes. OddsJam's Gold plan ($99/month) includes API access to their arbitrage ("sure bet") opportunities alongside their +EV endpoints. The arb API covers US sportsbooks and returns both the event details and the per-book odds required to calculate and place both legs. API documentation is self-serve.
Does RebelBetting have an arbitrage API?
Yes, but not as a self-service product. RebelBetting's arbitrage feed is available through their Custom Solutions programme. Contact their team to discuss scope and pricing. Their sure betting scanner covers 90+ EU and international bookmakers — the API mirrors this coverage.
Can I automate both legs of an arbitrage bet?
Yes for exchange and broker accounts (Betfair Exchange API, MadMarket, SportMarket). No for most soft bookmakers — automation violates their Terms of Service and risks account closure. The common pattern is: automate Leg A at a broker or exchange, place Leg B manually at the soft book. Claw Arbs automates both legs at its supported venues (Kalshi, Polymarket, Sportmarket, Pinnacle, Cloudbet, and more).
What causes an arbitrage opportunity to disappear before I can place both legs?
Bookmakers continuously update lines. An arb that existed when the API returned it may be gone by the time you access the bookmaker page. Pre-match arbs at softer books typically persist for 30 seconds to 5 minutes. Live arbs typically persist for 2–15 seconds. The API response includes a timestamp — check how stale the opportunity is before attempting to execute. The BetBurger API returns the age of each arb to help you assess this.
What is the difference between pre-match and live arbitrage APIs?
Pre-match arb APIs monitor odds before an event starts. Opportunities are more stable (minutes, not seconds) but margins are lower (typically 1–3%). Live arb APIs monitor in-play odds during active events. Opportunities disappear in seconds but margins are higher (2–8%) because books disagree more during live action. BetBurger separates them into two distinct API endpoints. OddsJam covers both via a single API with an in-play flag.
