Arbitrage betting is the closest thing to a guaranteed return that exists in gambling — and it is not gambling at all. When two bookmakers disagree enough about the same match, you bet every possible outcome across different books and the math locks in a profit no matter who wins. No prediction. No luck. Just a pricing error you get paid to exploit.
The catch: these gaps live for minutes, sometimes less. Humans with a spreadsheet lose to bots every time. This article gives you the bot.
What follows is a complete, working scanner built on The Odds API — one API call returns head-to-head odds from dozens of bookmakers, the script does the math, and you get a ranked list of every live arbitrage above your profit threshold. The code in this article was executed and passed all assertions (test harness included below, run with mocked API data — more on that in the disclosure).
The Math: Why a “Surebet” Actually Exists
A bookmaker’s odds imply a probability. If one book prices a tennis match at Sinner 2.08 / Alcaraz 1.92, converting to implied probability:
- Sinner: 1 ÷ 2.08 = 48.1%
- Alcaraz: 1 ÷ 1.92 = 52.1%
- Total: 100.2% — the extra 0.2% is the bookmaker’s margin (the “vig”). Betting both sides at this one book always loses long-term.
But you are not restricted to one book. Suppose another book prices Alcaraz at 1.97 instead. Now:
- Sinner 2.08 (book A): 48.1%
- Alcaraz 1.97 (book B): 50.8%
- Total: 98.9%
The two books combined are offering more than 100% of probability. That 1.1% gap is a surebet — a guaranteed profit if you size your stakes correctly. No outcome of the match can change it. Industry sources put typical arb margins at 0.5–3% per bet in football markets, with rare outliers going higher (and disappearing faster, because a 5% gap means someone made a serious mistake and their risk team is already on it).
Stake sizing is proportional to the inverse of each odds. For a $1,000 bankroll on the 2.08/1.97 pair:
- Sinner stake: $1,000 × (1/2.08) ÷ (1/2.08 + 1/1.97) = $486.42
- Alcaraz stake: $513.58
- If Sinner wins: $486.42 × 2.08 = $1,011.75
- If Alcaraz wins: $513.58 × 1.97 = $1,011.75
Either way you receive $1,011.75 on $1,000 deployed. $11.75 locked, 1.16% risk-free, before any human decides anything.
Why This Beats Every Other “Betting Strategy”
Matched betting needs bonus promotions to survive. +EV betting needs volume and a long runway before variance pays you. Polymarket arbitrage is real but the venue list is short and margins compress fast. Cross-bookmaker arbitrage is different in one critical way: the profit is structural, not statistical.
You are not betting on outcomes. You are exploiting the fact that 40+ independent companies run their own pricing engines, each with its own risk exposure, feed latency, and mistakes. A promoted team’s odds move on Pinnacle before they move on a regional book. A lazy trader copy-pastes a stale line. A big public bet moves one book and not another. Every one of those is money on the table, and a bot picks it up in seconds.
This is also why bookmakers hate it. More on that in the risk section — it matters more than the math does.
The Stack
- The Odds API — one endpoint, aggregated odds from 40+ bookmakers (Pinnacle, Betfair Exchange, Williamhill, Onexbet, and more). Free tier: 500 credits/month, all sports, most bookmakers. Paid tiers: 20,000 credits at $30/month, 100,000 at $59/month (prices verified from the-odds-api.com at time of writing). One API call costs 1 credit per region per market — so a scan across 2 regions on the h2h market is 2 credits, and the free tier covers roughly 250 such scans a month.
- Python 3.8+ — stdlib only. No pandas, no scraping, no proxy pool. The API does the hard part.
- Cron — run it every few minutes during peak match hours; each cycle costs 2 credits.
Get a key at the-odds-api.com, it arrives by email, free tier needs no card.
The Scanner, Full Source
Save as arb_scanner.py. Two parts matter: extract_h2h normalizes each bookmaker’s prices into a flat dict, and scan() takes the best available price per outcome across all books, checks whether the inverse-sum drops below 1, and — if it does — sizes every stake so every leg pays out identically.
#!/usr/bin/env python3
"""
Cross-bookmaker odds arbitrage ('surebet') scanner — The Odds API v4.
Tested end-to-end with mocked API responses (no paid key needed to run tests).
Set ODDS_API_KEY env var to run live (free tier: 500 credits/month, 1 credit
per region per market per call).
"""
import json
import os
import sys
import urllib.request
import urllib.error
API_BASE = "https://api.the-odds-api.com/v4"
REGIONS = "eu,uk" # comma-separated bookmaker regions
MARKETS = "h2h" # head-to-head (moneyline) — cheapest useful market
MIN_ARB_PCT = 0.5 # ignore arbs below this margin (too thin to survive delay)
BANKROLL = 1000.0 # total capital deployed across both legs
# ---------------------------------------------------------------- data layer
def fetch_odds(sport_key: str, api_key: str) -> dict:
"""One API call = 1 credit (per region per market)."""
url = (f"{API_BASE}/sports/{sport_key}/odds/"
f"?apiKey={api_key}®ions={REGIONS}&markets={MARKETS}&oddsFormat=decimal")
req = urllib.request.Request(url, headers={"User-Agent": "arb-scanner/1.0"})
with urllib.request.urlopen(req, timeout=30) as resp:
payload = json.loads(resp.read().decode())
quota = {
"remaining": resp.headers.get("x-requests-remaining"),
"used": resp.headers.get("x-requests-used"),
"last_cost": resp.headers.get("x-requests-last"),
}
return {"events": payload, "quota": quota}
def extract_h2h(event: dict) -> dict:
"""Flatten an event into {bookmaker: {outcome_name: decimal_price}}."""
book_odds = {}
for bm in event.get("bookmakers", []):
for mkt in bm.get("markets", []):
if mkt.get("key") != "h2h":
continue
prices = {}
for oc in mkt.get("outcomes", []):
prices[oc["name"]] = float(oc["price"])
if len(prices) >= 2:
book_odds[bm["key"]] = prices
return book_odds
# ---------------------------------------------------------------- math layer
def best_prices(book_odds: dict) -> dict:
"""Best available decimal odds PER OUTCOME across all books.
Handles any market shape (2-way tennis/NBA moneyline, 3-way soccer 1X2).
Returns {outcome_name: (best_price, book_key)}."""
best = {}
for book, prices in book_odds.items():
for outcome, price in prices.items():
if price > best.get(outcome, (0.0, None))[0]:
best[outcome] = (price, book)
return best
def arb_pct(odds_a: float, odds_b: float) -> float:
"""Arb margin % = 100 * (1/oa + 1/ob) - 100 ... negative means guaranteed profit.
We report profit margin = -that + ... keep it simple: (1 - sum) * 100."""
return (1.0 - (1.0 / odds_a + 1.0 / odds_b)) * 100.0
def stake_split(odds_a: float, odds_b: float, bankroll: float):
"""Stakes proportional to inverse odds -> identical payout either side.
Stakes rounded to cents (real bets can't be fractional); payout is the
guaranteed (lower) leg, profit is what you actually lock in."""
inv_a, inv_b = 1.0 / odds_a, 1.0 / odds_b
total = inv_a + inv_b
s_a = round(bankroll * inv_a / total, 2)
s_b = round(bankroll - s_a, 2)
payout = round(min(s_a * odds_a, s_b * odds_b), 2)
profit = round(payout - bankroll, 2)
return s_a, s_b, payout, profit
def scan(events: list, min_arb_pct: float = MIN_ARB_PCT) -> list:
arbs = []
for ev in events:
books = extract_h2h(ev)
best = best_prices(books)
if len(best) < 2:
continue
books_used = {b for _, b in best.values()}
if len(books_used) < 2:
continue # one book holds every best price = not a cross-book arb
inv_sum = sum(1.0 / p for p, _ in best.values())
profit_pct = (1.0 - inv_sum) * 100.0
if profit_pct < min_arb_pct:
continue
legs, payout, profit = [], 0.0, None
for name, (price, book) in best.items():
s = round(BANKROLL * (1.0 / price) / inv_sum, 2)
p = round(s * price, 2)
payout = min(payout, p) if payout else p
legs.append({"outcome": name, "price": price, "book": book, "stake": s})
profit = round(payout - BANKROLL, 2)
arbs.append({
"match": f'{ev.get("home_team")} vs {ev.get("away_team")}',
"commence": ev.get("commence_time"),
"outcomes": len(legs),
"legs": legs,
"profit_pct": round(profit_pct, 2),
"payout": payout, "profit": profit,
})
return sorted(arbs, key=lambda x: -x["profit_pct"])
def main() -> int:
api_key = os.environ.get("ODDS_API_KEY", "").strip()
if not api_key:
print("Set ODDS_API_KEY (free at the-odds-api.com)", file=sys.stderr)
return 1
quota = None
for sport in ("soccer_epl", "basketball_nba"):
try:
data = fetch_odds(sport, api_key)
except urllib.error.HTTPError as e:
print(f"[WARN] live fetch {sport} failed: HTTP {e.code}", file=sys.stderr)
continue
quota = data["quota"]
found = scan(data["events"])
print(f"[LIVE] {sport}: {len(data['events'])} events, {len(found)} arbs >= {MIN_ARB_PCT}%")
for a in found[:5]:
legs = " / ".join(f"{l['outcome']} @{l['price']} ({l['book']})" for l in a["legs"])
print(f" {a['match']}: {legs} -> {a['profit_pct']}% = ${a['profit']} profit")
if quota:
print(f"[QUOTA] remaining={quota['remaining']} used={quota['used']} last_cost={quota['last_cost']}")
return 0
if __name__ == "__main__":
sys.exit(main())
Three design decisions worth understanding, because they are where naive arbitrage scripts go wrong:
1. Three-way markets are handled, not ignored. Soccer 1X2 has three outcomes — home, draw, away. A 2-way scanner on a soccer match will happily flag “arb” pairs that ignore the draw entirely, and the draw happening is exactly when your “guaranteed” profit evaporates into a total loss. best_prices treats it as an N-outcome problem: the inverse-sum check runs over all outcomes, and the stake-splitter covers every one of them.
2. Same-book pairs are rejected. If Pinnacle holds the best price on both sides, the margin you compute is against itself — which is always negative after the vig. That is not an arbitrage, it is arithmetic that hasn’t finished yet. The len(books_used) < 2 check kills it.
3. The threshold is 0.5%, not 0.01%. Real arb windows collapse in seconds. A 0.4% arb that takes you 90 seconds to place two legs at different bookmakers is, after settlement risk, closer to a coin flip than a guarantee. Setting MIN_ARB_PCT = 0.5 filters out the noise that exists only in the API snapshot and never in the real market.
Proof It Works: The Test Harness
I do not publish code I haven’t run. Below is the actual test file (arb_scanner_test.py in full — imports, mocks, assertions) that validates every function in the scanner before any real API call is made. Run python3 arb_scanner_test.py — it exits 0 only if the arbitrage math, the N-outcome handling, the same-book rejection, and the no-arb control all behave correctly.
#!/usr/bin/env python3
"""
Cross-bookmaker odds arbitrage ('surebet') scanner — The Odds API v4.
Tested end-to-end with mocked API responses (no paid key needed to run tests).
Set ODDS_API_KEY env var to run live (free tier: 500 credits/month, 1 credit
per region per market per call).
"""
import json
import os
import sys
import urllib.request
import urllib.error
API_BASE = "https://api.the-odds-api.com/v4"
REGIONS = "eu,uk" # comma-separated bookmaker regions
MARKETS = "h2h" # head-to-head (moneyline) — cheapest useful market
MIN_ARB_PCT = 0.5 # ignore arbs below this margin (too thin to survive delay)
BANKROLL = 1000.0 # total capital deployed across both legs
# ---------------------------------------------------------------- data layer
def fetch_odds(sport_key: str, api_key: str) -> dict:
"""One API call = 1 credit (per region per market)."""
url = (f"{API_BASE}/sports/{sport_key}/odds/"
f"?apiKey={api_key}®ions={REGIONS}&markets={MARKETS}&oddsFormat=decimal")
req = urllib.request.Request(url, headers={"User-Agent": "arb-scanner/1.0"})
with urllib.request.urlopen(req, timeout=30) as resp:
payload = json.loads(resp.read().decode())
quota = {
"remaining": resp.headers.get("x-requests-remaining"),
"used": resp.headers.get("x-requests-used"),
"last_cost": resp.headers.get("x-requests-last"),
}
return {"events": payload, "quota": quota}
def extract_h2h(event: dict) -> dict:
"""Flatten an event into {bookmaker: {outcome_name: decimal_price}}."""
book_odds = {}
for bm in event.get("bookmakers", []):
for mkt in bm.get("markets", []):
if mkt.get("key") != "h2h":
continue
prices = {}
for oc in mkt.get("outcomes", []):
prices[oc["name"]] = float(oc["price"])
if len(prices) >= 2:
book_odds[bm["key"]] = prices
return book_odds
# ---------------------------------------------------------------- math layer
def best_prices(book_odds: dict) -> dict:
"""Best available decimal odds PER OUTCOME across all books.
Handles any market shape (2-way tennis/NBA moneyline, 3-way soccer 1X2).
Returns {outcome_name: (best_price, book_key)}."""
best = {}
for book, prices in book_odds.items():
for outcome, price in prices.items():
if price > best.get(outcome, (0.0, None))[0]:
best[outcome] = (price, book)
return best
def arb_pct(odds_a: float, odds_b: float) -> float:
"""Arb margin % = 100 * (1/oa + 1/ob) - 100 ... negative means guaranteed profit.
We report profit margin = -that + ... keep it simple: (1 - sum) * 100."""
return (1.0 - (1.0 / odds_a + 1.0 / odds_b)) * 100.0
def stake_split(odds_a: float, odds_b: float, bankroll: float):
"""Stakes proportional to inverse odds -> identical payout either side.
Stakes rounded to cents (real bets can't be fractional); payout is the
guaranteed (lower) leg, profit is what you actually lock in."""
inv_a, inv_b = 1.0 / odds_a, 1.0 / odds_b
total = inv_a + inv_b
s_a = round(bankroll * inv_a / total, 2)
s_b = round(bankroll - s_a, 2)
payout = round(min(s_a * odds_a, s_b * odds_b), 2)
profit = round(payout - bankroll, 2)
return s_a, s_b, payout, profit
def scan(events: list, min_arb_pct: float = MIN_ARB_PCT) -> list:
arbs = []
for ev in events:
books = extract_h2h(ev)
best = best_prices(books)
if len(best) < 2:
continue
books_used = {b for _, b in best.values()}
if len(books_used) < 2:
continue # one book holds every best price = not a cross-book arb
inv_sum = sum(1.0 / p for p, _ in best.values())
profit_pct = (1.0 - inv_sum) * 100.0
if profit_pct < min_arb_pct:
continue
legs, payout, profit = [], 0.0, None
for name, (price, book) in best.items():
s = round(BANKROLL * (1.0 / price) / inv_sum, 2)
p = round(s * price, 2)
payout = min(payout, p) if payout else p
legs.append({"outcome": name, "price": price, "book": book, "stake": s})
profit = round(payout - BANKROLL, 2)
arbs.append({
"match": f'{ev.get("home_team")} vs {ev.get("away_team")}',
"commence": ev.get("commence_time"),
"outcomes": len(legs),
"legs": legs,
"profit_pct": round(profit_pct, 2),
"payout": payout, "profit": profit,
})
return sorted(arbs, key=lambda x: -x["profit_pct"])
# ---------------------------------------------------------------- test harness
MOCK_EVENTS = [
# tennis 2-way: realistic thin arb (~1.2%) spread across two books
{
"id": "evt1", "sport_key": "atp_french_open",
"home_team": "J. Sinner", "away_team": "C. Alcaraz",
"commence_time": "2026-10-27T20:00:00Z",
"bookmakers": [
{"key": "pinnacle", "markets": [{"key": "h2h", "outcomes": [
{"name": "J. Sinner", "price": 2.08}, {"name": "C. Alcaraz", "price": 1.92}]}]},
{"key": "betfair_ex_eu", "markets": [{"key": "h2h", "outcomes": [
{"name": "J. Sinner", "price": 1.94}, {"name": "C. Alcaraz", "price": 1.97}]}]},
],
},
# soccer 3-way (1X2): arb requires ALL THREE outcomes covered
{
"id": "evt2", "sport_key": "soccer_epl",
"home_team": "Arsenal", "away_team": "Chelsea",
"commence_time": "2026-10-28T17:30:00Z",
"bookmakers": [
{"key": "pinnacle", "markets": [{"key": "h2h", "outcomes": [
{"name": "Arsenal", "price": 2.30}, {"name": "Draw", "price": 3.55},
{"name": "Chelsea", "price": 3.90}]}]},
{"key": "onexbet", "markets": [{"key": "h2h", "outcomes": [
{"name": "Arsenal", "price": 2.10}, {"name": "Draw", "price": 3.90},
{"name": "Chelsea", "price": 4.10}]}]},
{"key": "williamhill", "markets": [{"key": "h2h", "outcomes": [
{"name": "Arsenal", "price": 2.20}, {"name": "Draw", "price": 3.60},
{"name": "Chelsea", "price": 3.70}]}]},
],
},
# no-arb control: normal margin, must NOT appear
{
"id": "evt3", "sport_key": "basketball_nba",
"home_team": "Lakers", "away_team": "Celtics",
"commence_time": "2026-10-27T02:30:00Z",
"bookmakers": [
{"key": "pinnacle", "markets": [{"key": "h2h", "outcomes": [
{"name": "Lakers", "price": 1.85}, {"name": "Celtics", "price": 2.05}]}]},
{"key": "williamhill", "markets": [{"key": "h2h", "outcomes": [
{"name": "Lakers", "price": 1.80}, {"name": "Celtics", "price": 2.10}]}]},
],
},
]
def run_tests() -> None:
# math unit checks
assert arb_pct(2.08, 1.97) > 0, "2.08/1.97 must be an arb"
assert arb_pct(1.85, 2.05) < 0, "1.85/2.05 must NOT be an arb"
s_a, s_b, payout, profit = stake_split(2.08, 1.97, 1000)
assert abs(s_a + s_b - 1000) < 0.01, "stakes must sum to bankroll"
assert abs(s_a * 2.08 - payout) <= 0.02 and abs(s_b * 1.97 - payout) <= 0.02, \
"legs must pay out within a cent or two of each other"
assert profit > 0
arbs = scan(MOCK_EVENTS, min_arb_pct=0.5)
matches = [a["match"] for a in arbs]
assert "J. Sinner vs C. Alcaraz" in matches, f"tennis arb missing: {matches}"
assert "Arsenal vs Chelsea" in matches, f"soccer 1X2 arb missing: {matches}"
assert all(a["match"] != "Lakers vs Celtics" for a in arbs), "control event leaked"
tennis = next(a for a in arbs if a["match"] == "J. Sinner vs C. Alcaraz")
assert tennis["outcomes"] == 2 and 0 < tennis["profit_pct"] < 5, \
f"tennis margin unrealistic: {tennis['profit_pct']}%"
soccer = next(a for a in arbs if a["match"] == "Arsenal vs Chelsea")
assert soccer["outcomes"] == 3, "1X2 arb must cover exactly 3 legs"
assert abs(sum(l["stake"] for l in soccer["legs"]) - BANKROLL) < 0.05, \
"soccer leg stakes must sum to bankroll"
assert soccer["profit"] > 0
print(f"[PASS] unit math + mock scan ({len(arbs)} arbs found, control excluded)")
for a in arbs:
print(f" {a['match']} ({a['outcomes']}-way, {a['profit_pct']}%):")
for l in a["legs"]:
print(f" {l['outcome']:<14} @ {l['price']:<5} on {l['book']:<14} stake ${l['stake']}")
print(f" -> payout ${a['payout']} locked profit ${a['profit']}")
def main() -> int:
run_tests()
api_key = os.environ.get("ODDS_API_KEY", "").strip()
if not api_key:
print("[NOTE] ODDS_API_KEY not set — skipped live fetch "
"(tested with mocked API responses; run once with your real key).")
return 0
quota = None
for sport in ("soccer_epl", "basketball_nba"):
try:
data = fetch_odds(sport, api_key)
except urllib.error.HTTPError as e:
print(f"[WARN] live fetch {sport} failed: HTTP {e.code}", file=sys.stderr)
continue
quota = data["quota"]
found = scan(data["events"])
print(f"[LIVE] {sport}: {len(data['events'])} events, {len(found)} arbs >= {MIN_ARB_PCT}%")
for a in found[:5]:
legs = " / ".join(f"{l['outcome']} @{l['price']} ({l['book']})" for l in a["legs"])
print(f" {a['match']}: {legs} -> {a['profit_pct']}% = ${a['profit']} profit")
if quota:
print(f"[QUOTA] remaining={quota['remaining']} used={quota['used']} last_cost={quota['last_cost']}")
return 0
if __name__ == "__main__":
sys.exit(main())
Actual output from the run I executed before publishing this article:
[PASS] unit math + mock scan (2 arbs found, control excluded)
Arsenal vs Chelsea (3-way, 6.49%):
Arsenal @ 2.3 on pinnacle stake $464.96
Draw @ 3.9 on onexbet stake $274.21
Chelsea @ 4.1 on onexbet stake $260.83
-> payout $1069.4 locked profit $69.4
J. Sinner vs C. Alcaraz (2-way, 1.16%):
J. Sinner @ 2.08 on pinnacle stake $486.42
C. Alcaraz @ 1.97 on betfair_ex_eu stake $513.58
-> payout $1011.75 locked profit $11.75
[NOTE] ODDS_API_KEY not set — skipped live fetch (tested with mocked API responses; run once with your real key).
Disclosure: tested with mocked API responses. The math layer is 100% real and verified — the assertions above prove the stake-splitting, the payout-equality invariant, and the N-outcome handling all hold. To run it against the live market, get a free key at the-odds-api.com, export ODDS_API_KEY=your_key_here, and run python3 arb_scanner_test.py once — the live fetch path activates automatically and prints your remaining credit balance from the x-requests-remaining response header.
Running It Live Without Burning 500 Credits in a Day
Each scan of one sport across two regions costs 2 credits (1 credit per region per market). The free 500/month works out to roughly 250 scans — enough to validate the strategy over a week, not enough to run a serious operation. Three rules to stay inside the quota:
- Scan only around event windows. Arbs cluster in the 2 hours before kickoff and the first minutes of live play. Cron at
*/5 12-22 * * *covers peak windows at 25% of the cost of 24/7 scanning. - One sport per cycle.
soccer_eplalone, not a loop over 30 leagues. Add sports only when you have a paid tier and a reason. - Alert, don’t act. The scanner should write to Telegram or a log — not place bets. Manual placement keeps you in the loop for the settlement-risk judgment calls described below.
Scaling economics: at the $30/month tier (20,000 credits) you can scan ~10 sports every 5 minutes around the clock (10 sports × 12 scans/hour × 24 hours × 30 days × 2 credits = 172,800 — one sport every 5 min continuously is ~17,280 credits, leaving headroom). The math: each 1% arb on a $1,000 deployment returns $10. Catching one arbed match per day at 1% on a $1,000 float is ~$300/month. Catching three, on a $3,000 float spread across books, is ~$2,700/month — before taxes, before the cost of capital sitting in five bookmaker accounts, and before the risks below, which are the real cost of this business.
The Risks That Actually Matter (Read This Twice)
The math is bulletproof. The business is not. Three failure modes, in order of how much money they cost people:
1. Account limiting — the eventual outcome for every successful arber. Bookmakers profit from recreational bettors and lose to arbers, so they invest heavily in detecting them. Odds comparison services and risk teams flag accounts whose bets consistently land on out-of-line prices at exactly the moment gaps appear. Industry guides on arbitrage are explicit: sportsbooks can and do limit accounts — cutting your maximum stake to trivial amounts — once identified, and this is not a matter of “if” but “when” for anyone running volume. Strategies to delay it (round stake amounts, bet the occasional recreational parlay, avoid maxing out on every arb, spread across many books) buy time, not immunity.
2. Settlement risk — when one leg gets voided. If a bookmaker voids a bet due to a palpable error in the odds (their terms usually allow this), you are left with one leg of an arbitrage exposed as a straight bet. This is how arbers actually lose money: not on the math, but on one leg standing alone against a market that moved. Higher-margin arbs are more likely to involve errors and more likely to be voided. Another reason the 0.5% threshold is your friend.
3. Capital fragmentation. This strategy only works if money is already sitting at each bookmaker. A $1,000 bankroll split across five books is $200 per book — thin enough that many arbs become unplaceable at meaningful size, and withdrawal/transfer friction between books eats hours per week. Treat float size as a real constraint, not a detail.
None of these make arbitrage a bad strategy. They make it a job — one with a real edge, real constraints, and a shelf life at any given bookmaker. Whether that trade is worth it depends entirely on your capital and how much you enjoy operations.
Is This Legal?
Placing bets at whatever odds a bookmaker publishes is legal in every jurisdiction where sports betting itself is legal. Arbitrage is not fraud — you are accepting prices they offered. It is, however, almost universally against bookmakers’ interests, and their terms of service typically allow them to limit, restrict, or void bets at their discretion — which is why account limiting is the operational ceiling here, not law enforcement. Check your local gambling laws and the specific terms of every book you use. Betfair Exchange works differently: other users set the odds, so “limiting” works differently there too, and it is the single most arb-friendly venue in the ecosystem for that reason.
Your First Week
- Get the free Odds API key (500 credits, no card).
- Run the scanner against one sport, manually, a few times a day — get a feel for how often arbs appear above 0.5%.
- When you see one, do NOT bet it. Open both books, check the odds still exist, price the stake yourself. Closing speed is the real skill.
- Only after a week of watching: fund two books with small amounts, take one 1%+ arb, and see how long the window actually stays open.
- Scale float and sports count only once you’ve felt settlement risk and capital fragmentation firsthand — they’re the real constraints, and no article can simulate them for you.
The gap between reading about arbitrage and doing it is entirely operational. The code above removes the excuse that you can’t find the opportunities. What’s left is capital, speed, and how long the books let you keep the account.