Prediction markets and offshore sportsbooks price the same events differently. Different customer bases, different pricing models, different information flows. Where those prices disagree enough, you can lock in guaranteed profit — regardless of the outcome.
This isn’t theoretical. Election futures on Polymarket regularly diverge from offshore sportsbook lines by 3–8 percentage points. Championship futures, award show outcomes, and major geopolitical events show similar gaps. The mechanics are straightforward: buy the underpriced side on one platform, bet the other side on the other, and collect the difference.
This guide shows you how to find those opportunities, convert between odds formats, build a scanner, and handle the execution challenges that make cross-platform arbs harder than they look on paper.
Prerequisites: Familiarity with at least one prediction market API (Polymarket or Kalshi) and a basic understanding of offshore sportsbook odds. If you need background, start with Prediction Markets vs. Offshore Sportsbooks.
Why Cross-Platform Arbs Exist
Traditional same-book arbitrage (arbing between two sportsbooks) is well-understood and increasingly hard to find. Sportsbooks share information, react to the same sharp action, and converge on prices quickly. Cross-platform arbs between prediction markets and offshore sportsbooks are different — they persist longer and emerge from structural causes, not just temporary mispricings.
Different Market Structures
Prediction markets are exchanges. Polymarket runs a Central Limit Order Book where traders set prices by placing limit orders. The price reflects the balance of buyer and seller conviction. Offshore sportsbooks are bookmakers — they set the odds, build in a margin, and adjust based on the action they receive. These two mechanisms can price the same event differently even with identical information, because they aggregate that information through fundamentally different processes.
Different Customer Bases
Polymarket’s user base skews toward crypto-native traders, quantitative modelers, and political analysts. Offshore sportsbook customers skew toward recreational sports bettors who occasionally dabble in political or entertainment futures. When a political model shows a candidate surging, Polymarket reprices in minutes. The same information might take hours to filter into BetOnline’s political futures, because their customers aren’t watching the same signals.
Different Information Propagation
Order book markets react to new information through price discovery — traders compete to incorporate signals. Bookmaker markets react through line movement — the book adjusts when betting action skews one direction. The lag between these two reaction mechanisms is where arb windows open.
Different Fee Structures
Polymarket takes ~2% of net winnings. Kalshi charges per-contract fees. Offshore sportsbooks build 5–10% vig into their odds. These different cost structures mean each platform’s “breakeven” price is different, which shifts where they’re willing to price an event. A sportsbook might need a wider spread to maintain its margin, while a prediction market’s tighter fees allow prices closer to true probability.
Odds Format Conversion
You can’t compare prices across platforms without converting everything to a common format. Implied probability is the universal language.
Prediction Market Prices
Polymarket prices are already probabilities. A contract trading at $0.62 implies a 62% chance. Kalshi works the same way — a contract at 62¢ is 62% implied.
American Odds
American odds use a plus/minus format. Positive odds (+170) tell you how much profit you win on a $100 stake. Negative odds (-150) tell you how much you must stake to win $100.
Decimal Odds
Decimal odds represent total return on a $1 bet. Odds of 2.70 mean $2.70 back (including your $1 stake) — implied probability 37%.
Conversion Functions
def american_to_implied(odds: int) -> float:
if odds > 0:
return 100 / (odds + 100)
return abs(odds) / (abs(odds) + 100)
def decimal_to_implied(odds: float) -> float:
return 1.0 / odds
def prediction_market_to_implied(price: float) -> float:
return price
def implied_to_american(prob: float) -> int:
if prob >= 0.5:
return int(-prob / (1 - prob) * 100)
return int((1 - prob) / prob * 100)
These four functions are the foundation of your cross-platform scanner. Every price from every platform passes through them before comparison.
Finding Matching Markets
Cross-platform arbitrage only works when both sides offer the same event. The overlap between prediction markets and offshore sportsbooks is narrower than you’d expect — but the markets that do overlap tend to be high-profile, liquid, and prone to significant price divergence.
High-Overlap Categories
Elections and politics. The richest arb territory. Polymarket runs deep markets on U.S. presidential, congressional, and gubernatorial races. Kalshi covers elections plus policy outcomes (Fed rate decisions, legislation). Offshore books like BetOnline and Bovada post political futures with American odds. The same candidate, priced by completely different populations — this is where 3–8 point implied probability gaps show up regularly.
Championship futures. “Who will win the Super Bowl / World Series / NBA Finals?” appears on both platform types. Prediction markets price these as binary contracts; sportsbooks price them as futures. Liquidity is usually deeper on the sportsbook side, but prediction markets occasionally offer better prices on longshots.
Entertainment and awards. Oscars, Grammys, reality TV outcomes. Polymarket has expanded into entertainment contracts, and offshore books have offered entertainment props for years. These markets are thinly traded on both sides, which creates wider spreads — and wider arb windows.
Market Matching Challenges
The same event might be named “Will Joe Biden win the 2028 election?” on Polymarket and listed as “2028 Presidential Election Winner: Joe Biden +350” on BetOnline. Your scanner needs fuzzy matching or a manually curated mapping table to connect these. Resolution criteria can also differ: Polymarket might resolve based on the Electoral College certification, while a sportsbook might grade based on the AP race call. These differences matter — see the Settlement Risk section.
Building the Cross-Platform Scanner
Here’s a Python scanner that pulls prices from both platform types, normalizes to implied probabilities, and flags arb opportunities.
import requests
from dataclasses import dataclass
@dataclass
class ArbOpportunity:
event: str
side_a: str
side_b: str
platform_a: str
platform_b: str
implied_a: float
implied_b: float
margin: float
stake_a: float
stake_b: float
profit: float
class CrossPlatformArbScanner:
def __init__(self, odds_api_key: str):
self.odds_api_key = odds_api_key
self.market_map: list[dict] = []
def add_market_pair(self, event: str, pm_price_yes: float,
sportsbook_odds_no: int, pm_platform: str = "Polymarket",
sb_platform: str = "BetOnline"):
self.market_map.append({
"event": event,
"pm_yes": pm_price_yes,
"sb_no_american": sportsbook_odds_no,
"pm_platform": pm_platform,
"sb_platform": sb_platform,
})
def fetch_sportsbook_odds(self, sport: str) -> list[dict]:
url = f"https://api.the-odds-api.com/v4/sports/{sport}/odds"
resp = requests.get(url, params={
"apiKey": self.odds_api_key,
"regions": "us",
"markets": "h2h",
"oddsFormat": "american",
})
resp.raise_for_status()
return resp.json()
@staticmethod
def american_to_implied(odds: int) -> float:
if odds > 0:
return 100 / (odds + 100)
return abs(odds) / (abs(odds) + 100)
def scan(self, total_stake: float = 1000.0) -> list[ArbOpportunity]:
opportunities = []
for pair in self.market_map:
implied_yes = pair["pm_yes"]
implied_no = self.american_to_implied(pair["sb_no_american"])
total_implied = implied_yes + implied_no
if total_implied < 1.0:
margin = 1.0 - total_implied
stake_a = total_stake * (implied_yes / total_implied)
stake_b = total_stake * (implied_no / total_implied)
profit = total_stake * margin / total_implied
opportunities.append(ArbOpportunity(
event=pair["event"],
side_a=f"YES @ {pair['pm_platform']}",
side_b=f"NO @ {pair['sb_platform']}",
platform_a=pair["pm_platform"],
platform_b=pair["sb_platform"],
implied_a=round(implied_yes, 4),
implied_b=round(implied_no, 4),
margin=round(margin, 4),
stake_a=round(stake_a, 2),
stake_b=round(stake_b, 2),
profit=round(profit, 2),
))
return opportunities
def report(self, total_stake: float = 1000.0):
arbs = self.scan(total_stake)
if not arbs:
print("No arbitrage opportunities found.")
return
for arb in arbs:
print(f"\n{'='*60}")
print(f"EVENT: {arb.event}")
print(f" {arb.side_a}: implied {arb.implied_a:.1%}")
print(f" {arb.side_b}: implied {arb.implied_b:.1%}")
print(f" Combined: {arb.implied_a + arb.implied_b:.1%}")
print(f" Margin: {arb.margin:.2%}")
print(f" Stake {arb.platform_a}: ${arb.stake_a:,.2f}")
print(f" Stake {arb.platform_b}: ${arb.stake_b:,.2f}")
print(f" Guaranteed profit: ${arb.profit:,.2f}")
Example: Election Arb
scanner = CrossPlatformArbScanner(odds_api_key="your-key")
# Polymarket has Candidate A at $0.62 (62% implied)
# BetOnline has Candidate A "No" at +170 (37% implied)
# Combined: 62% + 37% = 99% → 1% arb margin
scanner.add_market_pair(
event="2028 Presidential Election - Candidate A",
pm_price_yes=0.62,
sportsbook_odds_no=170,
)
scanner.report(total_stake=5000)
# EVENT: 2028 Presidential Election - Candidate A
# YES @ Polymarket: implied 62.0%
# NO @ BetOnline: implied 37.0%
# Combined: 99.0%
# Margin: 1.00%
# Stake Polymarket: $3,131.31
# Stake BetOnline: $1,868.69
# Guaranteed profit: $50.51
The scanner is intentionally simple. In production, you’d wire it to live Polymarket WebSocket feeds and The Odds API polling to detect opportunities in real time. The add_market_pair method is manual here — for scale, you’d build a market matching layer that automatically pairs equivalent contracts across platforms.
Execution Challenges
Finding the arb is the easy part. Executing it before it disappears is where most cross-platform strategies fail.
Speed Asymmetry
Your Polymarket leg executes via API in milliseconds — place a limit or market order through the CLOB client and you’re filled (or not) immediately. Your sportsbook leg requires either browser automation (Selenium/Playwright navigating the web interface) or manual placement. That latency gap — API call vs. page load, login, navigation, and bet slip submission — can be 10–30 seconds. In that window, either side can move.
Slippage
On Polymarket, thin order books mean your market order can eat through multiple price levels, shifting your effective entry. On offshore books, lines can move between your decision and confirmation, especially during live events. Budget for 0.5–1% of slippage on each side when evaluating whether an arb is worth pursuing. A 1% margin arb becomes a break-even or losing trade after slippage on both legs.
Settlement Timing Mismatch
This is the most overlooked challenge. Prediction market positions lock your capital until the market resolves — which might be months away for an election or futures market. Sportsbooks grade bets when the event concludes. Even on the same event, one platform might settle weeks before the other. Your capital is tied up on both sides for the duration of the slower platform’s settlement.
For elections specifically: Polymarket might resolve when the winner is certified. A sportsbook might grade when media outlets call the race. The gap between those events could be days.
Counterparty Risk
On Polymarket, your funds are in a smart contract — the counterparty risk is protocol risk. On Kalshi, you’re dealing with a CFTC-regulated entity. On an offshore sportsbook, you’re trusting an unregulated operator to pay out. If the sportsbook freezes your account or delays withdrawal, your “guaranteed profit” becomes an accounts receivable problem with no legal recourse.
Capital Lock-Up
Cross-platform arbs tie up capital on both platforms simultaneously. A $5,000 arb on a presidential election might lock $3,100 on Polymarket and $1,900 on BetOnline for months. That capital earns no return while locked — factor in opportunity cost when calculating whether a 1% guaranteed profit over six months is worth it compared to deploying that capital elsewhere.
Settlement Risk
Settlement risk is the scenario where both legs of your arb lose because the two platforms resolve the same event differently. It’s the only way a properly constructed arb can result in a total loss.
How It Happens
Prediction markets define resolution criteria in their market descriptions. Sportsbooks define grading rules in their house rules. These criteria can diverge in subtle but costly ways.
Example: “Will Candidate X win the presidency?” On Polymarket, this might resolve based on the Electoral College certification by Congress. On a sportsbook, it might grade based on the Associated Press race call. In a contested election, the AP could call the race for one candidate while the certification goes the other way — or is delayed indefinitely. One platform pays YES, the other pays YES to the opposite side. Both legs of your arb lose.
Common Divergence Points
- Timing of resolution: Sportsbooks typically grade faster (at event conclusion). Prediction markets might wait for official certification, final tallies, or arbitration.
- Edge cases and disputes: What happens if a candidate withdraws after election day? If a championship game is canceled? Each platform has different rules for voided or canceled events.
- “Push” vs. binary resolution: Sportsbooks can void/push bets under certain conditions. Prediction market binary contracts resolve YES or NO with no push — creating a mismatch if one side pushes and the other doesn’t.
Mitigating Settlement Risk
- Read both platforms’ resolution criteria before placing the arb. Compare them explicitly. If they diverge on any plausible scenario, skip the opportunity.
- Prefer markets with clear, binary outcomes where resolution is unambiguous — “Who wins the Super Bowl?” is safer than “Will Congress pass bill X by December 31?” where the definition of “pass” might vary.
- Check historical resolution disputes on both platforms. Polymarket’s resolution committee has overridden market creators before. Sportsbooks have grading disputes documented in forum threads. Prior behavior is your best predictor.
- Size your positions with settlement risk in mind. Don’t put 50% of your bankroll into a single cross-platform arb, no matter how wide the margin.
Putting It Into Practice
The cross-platform arb workflow in production looks like this:
- Monitor — Poll prediction market prices via API and sportsbook odds via The Odds API on a regular interval (every 1–5 minutes for active markets).
- Match — Map equivalent events across platforms using your curated market pair database.
- Convert — Normalize all prices to implied probabilities.
- Detect — Flag any market pair where combined implied probability drops below your threshold (typically 98–99% after accounting for slippage and fees).
- Validate — Check resolution criteria on both platforms. Confirm sufficient liquidity on the prediction market side and that the sportsbook line is still available.
- Execute — Place the prediction market leg via API first (faster, more certain). Then place the sportsbook leg immediately. If the sportsbook leg fails or the line moves, unwind the prediction market position.
- Track — Log both legs, monitor settlement, and reconcile when both sides resolve.
The math is simple. The execution and risk management is where your edge lives. Start with manual arbs on high-conviction market pairs (elections are the best starting point) before automating the full pipeline.
What’s Next
Go deeper on the platforms, strategies, and technical infrastructure:
- Prediction Markets vs. Offshore Sportsbooks — The full platform comparison for bot builders
- Middling Bot — A related strategy that exploits line movement within a single platform type
- Offshore Sportsbook APIs — How to access offshore book data programmatically
- Betting Bots for Offshore Sportsbooks — The complete guide to automation on offshore platforms
- Cross-Market Arbitrage Guide — The broader technical reference for multi-platform arb strategies