In 2014, a 22-year-old Brit named Daniel Dobson was arrested at the Australian Open for tapping scores into his phone faster than the official feed could publish them. He was, according to prosecutors, one of six people who flew around the world doing this professionally. The charge — engaging in conduct that would corrupt a betting outcome, under Victoria’s Crimes Act — was eventually dropped, but the industry reaction was not: tournaments started banning courtsiders, and data vendors like Sportradar built entire integrity divisions around the problem. Their 2024 report monitored more than 850,000 matches across 70 sports and flagged 1,108 suspicious ones.

Why would anyone fly to Melbourne to tap a phone? Because live betting markets reprice on information, and information has a physical speed. The sportsbook’s model updates when its data feed updates. Your TV picture is delayed by 5-10 seconds (satellite uplink, broadcast processing, streaming buffers). A courtsider with a ticket to a minor tennis event has an 8-second edge over the market. That edge is worth real money, which is why people were willing to get tackled by security for it.

The interesting engineering question — and the one this article is actually about — is: how close can you get to the courtsider’s edge from a VPS, with zero paid data feeds? I built a poller against ESPN’s open scoreboard API, pointed it at a live NFL game, and measured everything. The answer is more interesting than “yes” or “no.”

The latency stack, mapped

Every participant in the live-betting ecosystem sits at some depth in the same stack:

  • The venue. The point is scored. Information exists. Time zero.
  • The official data feed. League-licensed scouts or in-venue sensors push the event to data vendors (Sportradar, Genius Sports, Stats Perform). Sub-second to a few seconds, depending on the sport and the human in the chair.
  • The sportsbook. Reprices its in-play model within seconds of the vendor update. Sharper books faster, soft books slower.
  • The “free” score APIs. ESPN, Flashscore, Sofascore, etc. — most are downstream of the same official feeds, plus their own caching layers. This is the layer you can reach from a script.
  • Your TV stream. 5-10 seconds behind the venue. Reddit courtsiders who’ve compared sources report the broadcast commonly lags the venue by 5-6 seconds, and a “good game” (fewer camera cuts, faster confirms) around 10-12 seconds — treat those numbers as anecdotal, but the direction is not controversial.

The tradeable gap, if one exists for you, is between the free-API layer and the book’s repricing — not between the API and your couch. So the first thing to do is measure the API layer honestly: how fresh is it, how noisy is it, and what does it cost to watch it at full resolution?

The poller, tested against a live game

ESPN runs an undocumented but public and keyless scoreboard API. It’s the same endpoint the website itself polls. No API key, no auth, no ToS minefield beyond normal rate courtesy — this is the rare free data source that is exactly what it appears to be.

Here is the actual probe I ran (full file in scratch/latency-race/probe.py, executed live during the Patriots–Lions game on Nov 15, 2026, UTC 15:09–15:24):

import json, time, urllib.request

BASE = "https://site.api.espn.com/apis/site/v2/sports/{sport}/scoreboard"

def fetch(url, timeout=15):
    t0 = time.time()
    req = urllib.request.Request(url, headers={"User-Agent": "latency-probe/1.0"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        body = json.loads(r.read().decode())
    return body, time.time() - t0

def live_events(sport):
    data, dt = fetch(BASE.format(sport=sport))
    out = []
    for ev in data.get("events", []):
        st = ev.get("status", {}).get("type", {})
        if st.get("state") == "in":  # in-progress games only
            comp = ev["competitions"][0]
            home = next(c for c in comp["competitors"] if c.get("homeAway") == "home")
            away = next(c for c in comp["competitors"] if c.get("homeAway") == "away")
            out.append({
                "id": ev["id"],
                "matchup": f'{away["team"]["abbreviation"]} @ {home["team"]["abbreviation"]}',
                "clock": ev.get("status", {}).get("displayClock", "?"),
                "period": ev.get("status", {}).get("period", 0),
                "home_score": home.get("score"),
                "away_score": away.get("score"),
            })
    return out, dt

Then the measurement loop: poll every 10 seconds for 15 minutes, diff each snapshot against the last, and timestamp every score or clock change. During the run, Detroit scored a touchdown — the script watched the score step 3-7 → 3-13 → 3-14 across consecutive polls as the extra point was processed. That’s the feed working at full speed, captured in nfl_race.json:

poll 42 @ 15:16:33Z  NE @ DET: 3-13 Q2 12:57  (api_dt=5165ms)
poll 44 @ 15:16:58Z  NE @ DET: 3-14 Q2 12:57  (api_dt=5921ms)
poll 65 @ 15:20:47Z  NE @ DET: 3-14 Q2 12:52  (api_dt=39ms)

Ninety polls, thirteen change events, one live touchdown, zero API errors. The headline numbers:

  • API response time: 32ms min, 50ms median — this endpoint is fast and it is close to the pipe.
  • Four latency spikes between 2.1s and 8.4s — and here is the finding worth the price of the article: every spike coincided with a score-change write. When the feed’s underlying data updates, that endpoint takes several seconds to reflect it. The API isn’t slow; it’s occasionally stale right when it matters most. If you build on this layer, your “live” signal arrives up to 8 seconds late at the exact moments the market is repricing. Any edge you think you have from a free feed must be discounted by that number.

That one measurement changes the architecture: you don’t trade on the free feed’s score changes — you trade on the absence of a change, or you use the feed as a cheap cross-check against something faster. Which brings us to the money math.

Pricing the lead

Say the gap between your information and the book’s line is a few seconds. What is that actually worth? The honest tool is a two-leg arbitrage model with stake-splitting math, which is boring until you attach it to a execution-failure rate. Tested script (scratch/latency-race/edge_math.py, exit 0, deterministic, no network):

def stake_split(odds_a, odds_b):
    """stake 1.00 on leg A and o1/o2 on leg B to equalize payout"""
    s2 = odds_a / odds_b
    return s2, 1.0 + s2, odds_a

def arb_margin(odds_a, odds_b):
    s2, outlay, ret = stake_split(odds_a, odds_b)
    return (ret - outlay) / outlay * 100.0

With legs at decimal odds 2.10 and 1.95, the model says: put 1.00 on leg A, 1.0769 on leg B, total outlay 2.0769, guaranteed return 2.10 — a +1.11% risk-free margin if both legs get accepted. Run it across 120 bets on a 1,000 bankroll:

ScenarioBankroll after 120 bets
Perfect execution (every arb accepted)3,765.88
15% of legs voided (naked singles)1,151.96
Zero margin (no speed edge at all)1,000.00

The gap between rows one and two is the whole business model. Speed doesn’t create the margin — the margin only exists when the two books disagree faster than they can agree with each other. Speed creates acceptance rate: it determines whether your second leg lands at the stale price before the book pulls it. A bettor with an 8-second information lead gets quoted the stale line and clicks on it before the correction. A bettor watching TV clicks on a line that has already moved, and the “arb” silently becomes a naked single — the middle row, which compounds to roughly break-even-plus-a-little over a month. The model’s sanity checks refuse to lie about this (it failed my own first draft: I had the stake-split formula inverted, producing a nonsense +49% margin — the assertion arb_margin(2.00, 2.00) == 0 caught it before this article shipped. That’s why you test the math, not just the scraper).

One more honest number: sportsbooks now stream the same vendor data and are also watching sub-second signals. The 2024 U.S. commercial gaming market did $71.92 billion in revenue (AGA), with online gaming — sports betting plus casino — at $21.54 billion, roughly 30% of it. The engineering budgets on the other side of your trade are funded by that. You are not outbidding it. You are looking for the seconds it structurally cannot have: the book’s own feed is officially sourced, which means it is censored — delayed when the league’s feed delays, uniform across every book on that vendor. A free public feed is occasionally faster than the official one precisely because it isn’t bound by the league’s distribution deals. That asymmetry is the actual product.

The part where you don’t get arrested

Worth saying plainly, because the “aggressive” version of this article would bury it:

  • Victoria, Australia made this a criminal matter in 2013: Crimes Act s195C makes it an offence to engage in conduct that corrupts a betting outcome while intending a financial advantage — level 5, 10 years maximum. s195F covers using corrupt-conduct information for betting. Dobson’s charge was dropped in March 2014, but police explicitly said the drop was not an invitation. If you are physically inside a venue feeding data out, check the local law first — this is the one branch of the trade with prison attached.
  • Most jurisdictions’ online version is not criminal — it’s contract and ToS. Sportsbooks reserve the right to void bets, close accounts, and confiscate balances for “suspected courtsiding or latency abuse.” The risk profile is: your winning streak gets flagged, your account gets limited to pocket change, occasionally your balance gets held pending “review.” This is not a legal risk, it’s a counterparty risk — you are lending money to an adversarial bookkeeping system.
  • ESPN’s API is public and keyless, and this article’s usage — a few hundred polite GETs — is indistinguishable from their own web app. Scrape it like a guest: interval your polls, back off on errors, don’t run 50 threads at it.

What the system looks like when built properly

The poller above is one leg. The full desk — the thing you’d actually run — has four components, each of which is a standard engineering pattern this blog has covered before:

  1. Multi-source fan-in. Poll ESPN, Flashscore’s public endpoints, and Sofascore in parallel; treat each as an unreliable witness. The score is confirmed when two of three agree. This kills the 8-second staleness problem, because each source caches independently.
  2. Change detection with monotonic clocks. Game clock must move forward; score must move in legal increments. Anything else is a feed glitch, not a signal.
  3. The odds side. Books’ in-play lines via their own public endpoints or an odds aggregator (Pinnacle blocks datacenter IPs via Cloudflare out of the box — that’s a residential-proxy problem, not a data problem, and it’s the same problem every scraper business solves).
  4. Execution with a kill switch. The arb margin only survives if both legs confirm within a few seconds. The system must treat a dangling leg as a loss-in-progress and size accordingly — the middle row of the table above, not the top one.

Total infrastructure cost: a $6/month VPS and zero paid data feeds. Total build time for someone who’s done it before: a week. Total edge: measured in seconds, decaying every year as vendors close the gap — which is exactly why the desk is worth building now and exactly why it won’t be worth building in five.

The uncomfortable summary: the courtsider’s 8-second edge is real, physical, and mostly priced out of the free tier. What the free tier does give you — at 50ms median response and zero cost — is the ability to measure the gap precisely, cross-check every paid signal you might later buy, and build the fan-in architecture that any faster feed plugs into. Measure first, then pay for speed only where the measurement says speed pays.

Building a custom multi-source live-data pipeline, or want this desk wired to your own execution stack? Email [email protected] — we build these.