Lessons From $40M in Prediction Market Arbitrage for Quants and Devs

Exploitable, fee-adjusted arbitrage exists in prediction markets, but it is narrower and more operationally demanding than most quant traders assume. Three types produce real edge: cross-venue divergence, resolution-rule asymmetry, and liquidity-driven mispricings in thin books. Capturing any of them requires synchronized cross-venue feeds, canonical market IDs, and orderbook depth deep enough to validate that a signal is actually fillable. This piece builds the pipeline and the execution rules that separate paper arbitrage from cash.

TL;DR:

• Arbitrage opportunities in prediction markets are limited to three main types: within-market price drift, payoff inconsistencies across related markets, and price discrepancies between venues.

• Detecting real arbitrage requires synchronized data feeds, unique market identifiers, detailed orderbook depth, and monitoring of smart money activity to avoid false positives.

• Feasible arbitrage trades must cover costs including fees, slippage, and conversion primitives, with maximum position sizes constrained by market depth and execution validation.

• Infrastructure must incorporate phased validation, deterministic checks, and real-time orchestration to prevent strategic losses caused by protocol or data errors.

• Using advanced data layers like Assymetrix simplifies normalization across venues, enabling faster and more reliable identification and execution of prediction market arbitrage opportunities.

Table of Contents

• Three Arbitrage Types: Definitions and the Payoff Identities

• Data and Infrastructure: What Feeds, Schemas, and Signals You Must Have

• Execution Constraints and the Arbitrage Feasibility Checklist

• Detection Pipeline: Ingest, Embed, Validate, Size, Orchestrate

• Sizing, Risk Management, and Realtime Guardrails

• Backtesting and Simulation: No-Hindsight Replay and Capture Rate Calibration

• Statistical Models and Machine Learning for Spotting Arbitrage

• Regulatory and Legal Considerations in Prediction Market Arbitrage

• Real-World Case Studies Demonstrating Arbitrage Strategies

• Alternative Data Sources That Sharpen Arbitrage Signals

• Automation and Algorithmic Systems for Arbitrage Execution

• Dean’s Perspective: Build vs. Buy and the Ethics of Speed

• Assymetrix: The Data Layer for This Pipeline

• Sources

• FAQ

Three Arbitrage Types: Definitions and the Payoff Identities

Prediction market arbitrage rests on one identity: the prices of a complete, mutually exclusive outcome set must sum to $1.00. When they don’t, and when the deviation exceeds fees plus expected slippage, a risk-free basket exists on paper. Whether it exists in practice is a separate question.

Three distinct types dominate:

• Market Rebalancing arbitrage — within a single market, YES and NO prices drift apart from $1.00 due to order flow imbalance, creating a same-venue basket trade.

• Combinatorial arbitrage — related markets on the same platform (or the same event split across sub-markets) produce a payoff inconsistency across the outcome set.

• Cross-Platform Binary arbitrage — the same real-world event is priced differently on two venues, for example Kalshi and Polymarket both listing a Fed rate decision.

Empirical work on Polymarket found Market Rebalancing and Combinatorial patterns responsible for roughly $40 million in realized arbitrage profit over the sample period, using on-chain order book reconstruction. That figure sounds large until you notice the concentration: most of the profit clustered around a small number of high-volume events and specific protocol mechanics, not a steady background hum across the market. Execution still fails even when the payoff math is clean, often because a protocol adapter or a conversion primitive introduces asymmetric cost between the two legs of the trade.

Data and Infrastructure: What Feeds, Schemas, and Signals You Must Have

Detecting a real arbitrage candidate before it closes requires infrastructure most retail-facing tools don’t provide. Five components are non-negotiable:

1. Synchronized feeds with timestamp discipline. Cross-venue comparisons only mean something if both feeds are stamped against the same clock reference. Use NTP-corrected or monotonic timestamps, and treat any comparison built on client-side receipt time as unreliable.

2. Canonical market IDs. Two markets describing the same event on different venues rarely share a naming convention. You need deterministic mapping rules, not fuzzy string matching, to know that “Fed cuts rates in March” on one venue and “FOMC March decision: cut” on another are the same contract.

3. Orderbook depth and cumulative depth snapshots. A quoted best bid or ask means nothing without knowing how many contracts sit behind it. Depth snapshots let you compute the real executable size before you commit capital.

4. Fee metadata per venue. Maker/taker structures, settlement fees, and withdrawal costs vary and must be pulled into the same schema as price data, not bolted on afterward.

5. Actor traces and Smart Money signals. Optional, but high-signal: tracking wallets that consistently front-run divergence gives you an early warning that a gap is already being closed by someone faster than you.

Semantic embeddings can accelerate candidate discovery by clustering similarly-worded markets across venues, but embeddings alone are not proof of a match. Fuzzy matching without deterministic verification is a documented source of false-positive arbitrage signals.

Pro Tip: Build your candidate reduction with embeddings, then gate every candidate through a deterministic check on resolution source, expiry window, and outcome polarity before it ever reaches your sizing engine.

Execution Constraints and the Arbitrage Feasibility Checklist

A price gap is not an arbitrage until it survives a cost audit. For each leg, the executable cost is:

cost = best_ask + fee + estimated_slippage

The trade only clears the feasibility test when the sum of executable costs across all legs is strictly less than the guaranteed payout of $1.00 after fees and slippage. Miss this and you’ve found a spread, not an arbitrage.

Depth constrains size independently of price. Your maximum executable position is min(depth across all legs), not the depth on your best leg. A five-figure edge on a market with 40 contracts of depth on the thin side is a 40-contract trade, full stop.

Before sizing anything, run this validation checklist:

• Identical resolution source across both legs (same underlying data provider or official body).

• Aligned expiry and settlement windows, not just similar dates.

• Correct outcome polarity mapping, since “YES” on one venue can correspond to the inverse condition on another.

• Awareness of platform-specific conversion primitives (negative-risk adapters, settlement-based redemption) that change effective cost.

The practical consequence of skipping this checklist shows up in backtests: scanners routinely surface hundreds of raw discrepancies, but only a minority survive fee and slippage modeling once execution reality is applied. Treat every unvalidated gap as a hypothesis, not a position.

Detection Pipeline: Ingest, Embed, Validate, Size, Orchestrate

A production-grade scanner runs as five distinct phases, and Assymetrix data assets map directly onto each one.

1. Ingest and normalization. Raw trades and quotes from Polymarket, Kalshi, and Limitless get pulled into a canonical schema with preserved original timestamps. Assymetrix’s Data API already unifies these three venues under one schema, backed by roughly 1.5 terabytes of historical trading data across nearly one billion rows.

2. Vector candidate generation. Semantic recall clusters markets by title and description similarity across venues to shrink the comparison space from millions of pairs to a manageable candidate list.

3. Deterministic validation. Every candidate must pass event-identity checks, resolution-source parity, timing alignment, and explicit outcome mapping. This step, not the embedding step, is where most false positives get killed.

4. Arbitrage engine math. Surviving candidates get run through the executable-cost formula and depth-constrained sizing, producing a profit-per-unit and a maximum position size.

5. Orchestration. Live execution must handle partial fills, deduplicate repeated signals on the same underlying gap, and recompute incrementally as depth changes tick by tick.

This phased structure mirrors the ArbIt guaranteed-arbitrage engine architecture, which sequences ingest, embeddings, validation, and simulation into a repeatable production loop rather than a one-off script. Building this stack from scratch means writing your own venue adapters, timestamp reconciliation, and canonical ID mapping before you write a single line of arbitrage logic. That’s the part most independent quants underestimate.

Sizing, Risk Management, and Realtime Guardrails

Profit per unit is the guaranteed payout minus total executable cost across legs. Total guaranteed profit is that per-unit figure multiplied by your depth-constrained position size, min(depth across legs).

Sizing discipline matters more than signal frequency here. A few rules keep the engine from bleeding capital on edge cases:

• Cap position size at the shallowest leg’s available depth, never the average.

• Respect platform-imposed position limits independently of your own capital allocation rules.

• On ambiguous resolution language, default to skipping the trade; if you must participate, scale the position down or hold a hedged, smaller basket rather than a full-size unhedged bet.

• Track capital tied up across venues so a converter-enabled strategy on one platform doesn’t starve a settlement-based position on another.

Pro Tip: Treat withdrawal timing as part of your capital cost, not an afterthought. A locked withdrawal window on one venue can turn a profitable arbitrage into a working-capital drag if you can’t recycle inventory fast enough for the next signal.

Inventory recycling speed differs by mechanism: converter-enabled strategies typically free capital faster than settlement-based ones, since reconstructed converter-linked trades accounted for most observed mechanism-linked profit in recent protocol-execution research.

Backtesting and Simulation: No-Hindsight Replay and Capture Rate Calibration

A backtest that peeks at future orderbook states will always look profitable and always disappoint live. Replay engines must preserve historical depth snapshots exactly as they existed at decision time, never allowing a fill against liquidity that arrived after the signal.

1. Replay each candidate against the orderbook state available at signal time only, no lookahead.

2. Model partial fills against depth curves, not flat percentage slippage assumptions.

3. Apply venue-specific fees and account for platform downtime windows as missed opportunities, not neutral events.

4. Report capture rate, net profit after costs, capital efficiency, and annualized return as your core output set.

5. Run latency sensitivity tests at multiple detection-to-execution windows to see how fast the edge decays.

Realistic scanner simulations consistently show this decay pattern: the gap between gross discrepancies detected and net profit after execution modeling widens sharply as latency grows, which is the single biggest argument for infrastructure investment over strategy cleverness.

Statistical Models and Machine Learning for Spotting Arbitrage

Pure rule-based scanning catches obvious payoff violations, but statistical models extend detection into softer signals. A gradient-boosted classifier trained on historical spread behavior, resolution proximity, and volume imbalance can rank candidate gaps by likelihood of persisting long enough to fill, rather than treating every discrepancy as equally actionable.

Semantic embedding models solve a different problem: matching equivalent markets across venues that use different phrasing for the same event. That’s a candidate-generation tool, not a confirmation tool, and conflating the two is a documented source of realized losses when traders skip deterministic verification after the embedding match.

Time-series models add value in a third way: forecasting how quickly a given divergence historically closed on a specific venue pair helps you decide whether a signal is worth the execution risk or better left alone. A market where cross-venue gaps have historically closed within 90 seconds needs a faster pipeline than one where gaps have persisted for hours.

None of these models replace the deterministic validation layer. They rank and prioritize; they don’t confirm resolution-source equivalence or outcome polarity. Treat statistical scoring as a triage function sitting upstream of the feasibility checklist, feeding your highest-probability candidates into the arbitrage engine first while lower-scored candidates wait or get discarded.

Regulatory and Legal Considerations in Prediction Market Arbitrage

Arbitrage itself, the simultaneous purchase and sale of correlated positions to lock in a price discrepancy, is not illegal. It is a long-recognized trading strategy across regulated financial markets. What matters for prediction markets specifically is venue status and jurisdiction: Kalshi operates as a CFTC-regulated exchange, which brings a different compliance and reporting posture than platforms operating outside that framework.

Position limits, KYC requirements, and withdrawal rules differ by venue and are set by each platform’s own terms of service, not by a uniform prediction-market standard. A strategy that’s fully compliant on one venue can run into account restrictions on another simply because the platforms disagree on what counts as automated or high-frequency activity. Traders running bots across multiple venues need to read each platform’s terms directly rather than assume parity.

Tax treatment of arbitrage profits also varies by jurisdiction and by whether a venue issues tax documents. This article does not offer tax or legal advice, and the specifics change often enough that a blanket statement would age poorly. The practical guardrail is straightforward: verify your standing on each venue before scaling size, and treat platform terms of service as binding constraints on strategy design, not just background reading.

Real-World Case Studies Demonstrating Arbitrage Strategies

The clearest documented case comes from the Polymarket study that identified Market Rebalancing and Combinatorial arbitrage totaling roughly $40 million in realized profit. The researchers reconstructed the trades using on-chain order book and bid data, then applied heuristics to reduce the comparison space to a scale that could be verified against actual settled markets, not just theoretical price snapshots.

A second study on executable arbitrage went further, distinguishing payoff-space violations from ones a trader could actually capture. That work estimated $1.12 million in arbitrage profit split between converter-enabled and settlement-based execution channels, with converter-enabled, NO-side strategies accounting for the vast majority of the converter-linked share. The gap between the two studies’ figures is itself the case study: most payoff-space arbitrage never gets captured, because protocol mechanics and adapter costs eat the edge before a trader can act on it.

The pattern across both: profit concentrates around specific high-volume events and specific protocol primitives, not a smooth, evenly distributed edge available to anyone scanning prices. That’s consistent with what a synthetic-data scanner exercise also found. Raw discrepancy counts look abundant, but the subset that survives fee and slippage modeling shrinks fast, reinforcing that infrastructure quality, not signal volume, separates realized profit from a spreadsheet full of near-misses.

Alternative Data Sources That Sharpen Arbitrage Signals

Price and depth data alone tell you a gap exists. They don’t tell you whether it’s about to close because someone smarter than you already saw it. Wallet-level transaction traces fill that gap: tracking addresses with a consistent history of capturing cross-venue divergence gives you an early signal that a mispricing is being actively arbitraged, which should either accelerate your execution or make you skip a trade that’s already being closed.

Macro data feeds add a different layer. Kalshi’s regulated macro markets produce high-frequency, distributionally rich forecasts that the Federal Reserve’s own research has compared favorably against survey-based forecasts, which makes Kalshi price action a legitimate external signal for validating whether a divergence on a correlated market reflects new information or just thin-book noise.

News and event-timing feeds matter for combinatorial arbitrage specifically. A gap between related sub-markets on the same event can widen sharply around a scheduled data release, and knowing that release calendar ahead of time lets you distinguish a structural mispricing from one that will self-correct at a known timestamp.

Trader skill scoring, ranking wallets by historical accuracy and consistency rather than just volume, is an underused input. A divergence that’s being closed by historically accurate traders carries different information than one being closed by noise traders, and folding that distinction into your candidate ranking improves signal quality without adding a new data feed.

Automation and Algorithmic Systems for Arbitrage Execution

Manual arbitrage scanning doesn’t scale past a handful of markets. An automated system needs three layers working continuously: a detection layer polling normalized feeds and running the deterministic validation checklist, a sizing layer applying the depth-constrained position formula in real time, and an execution layer that submits orders across venues with awareness of each platform’s fill behavior.

Non-atomic execution is the core engineering problem. Unlike a single-venue trade, cross-venue arbitrage means your first leg can fill while your second leg’s price moves against you before you submit. Systems need to either submit both legs near-simultaneously with tight timeout logic, or size positions conservatively enough that partial exposure on one leg doesn’t create meaningful directional risk while the second leg completes.

Deduplication matters at scale. The same underlying gap can generate repeated signals across polling cycles, and without deduplication logic your system will attempt to size and re-size the same trade multiple times before the first attempt even settles. Incremental recomputation, updating only the markets that changed since the last poll rather than re-scanning the entire universe, keeps latency low enough to matter given how fast these gaps decay after detection.

Downtime handling rounds out the system. Venue API outages or maintenance windows need to pause the relevant leg’s execution logic entirely rather than let the system attempt a one-sided fill against a stale price.

Dean’s Perspective: Build vs. Buy and the Ethics of Speed

The honest tradeoff here is speed versus correctness versus cost, and most traders pick wrong on their first attempt. Building your own venue adapters, timestamp reconciliation, and canonical ID mapping from scratch teaches you the failure modes, but it also burns months you could spend refining sizing logic instead. Packaged historical datasets and normalized APIs earn their cost the moment you value your own time correctly.

There’s also a line worth respecting: exploiting a genuine payoff-space violation is legitimate arbitrage. Gaming resolution ambiguity, wash-trading to manipulate a book you plan to arbitrage against, or violating a venue’s terms on automated activity is not the same category of behavior, and no framework should blur that distinction.

— Dean

Assymetrix: The Data Layer for This Pipeline

Everything in this framework, canonical IDs, synchronized cross-venue timestamps, depth snapshots, and no-lookahead replay, depends on having a data layer that already solved the normalization problem before you write a single line of arbitrage logic. Assymetrix’s Data API unifies real-time and historical feeds across Polymarket, Kalshi, and Limitless under one schema, backed by roughly 1.5 terabytes of historical trading data spanning nearly one billion rows, with cross-venue arbitrage signals and Smart Money wallet tracking built in rather than bolted on.

If you’re building the detection pipeline described above, start with the Data API integration guide for the feed and schema layer, then read the Quant Strategy Guide for a deeper walkthrough of backtest design and execution sizing specific to Polymarket and Kalshi. For orderbook depth specifically, the orderbook integration guide covers the ingestion patterns this article’s feasibility checklist depends on. Try the API directly at Data to see how much infrastructure work the canonical schema replaces.

Sources

Core research: the Polymarket arbitrage study, the executable arbitrage paper, DataField’s arbitrage chapter, the ArbIt scanner repo, and BacktestMarket’s holiday-gap handling guide.

• Unravelling the Probabilistic Forest: Arbitrage in Prediction Markets

• ArbIt — Guaranteed Arbitrage Engine for Prediction Markets

• Chapter 16: Arbitrage in Prediction Markets | Prediction Markets

FAQ

What Is Arbitrage in Prediction Markets?

It’s the simultaneous purchase or sale of correlated contracts, within one market, across related markets, or across venues, to lock in a risk-free profit when combined prices deviate from the guaranteed $1.00 payout.

What Are the Three Types of Prediction Market Arbitrage?

Market Rebalancing (within-market price drift from $1.00), Combinatorial (payoff inconsistencies across related markets), and Cross-Platform Binary (the same event priced differently on two venues like Kalshi and Polymarket).

Can You Really Make Money With Prediction Market Arbitrage?

Yes, but the gains are concentrated: researchers estimated roughly $40 million in realized Polymarket arbitrage profit in one study period, while a separate executable-arbitrage analysis found only about $1.12 million actually capturable after accounting for protocol execution constraints.

Is Arbitrage Trading Illegal?

No, arbitrage is a standard, legal trading strategy in regulated markets including Kalshi’s CFTC-regulated exchange; the legal risk sits in platform-specific terms of service around automated activity and account limits, not in the arbitrage strategy itself.

How Does Assymetrix Help With Prediction Market Arbitrage?

Assymetrix supplies the unified feeds, canonical market IDs, and orderbook depth data across Polymarket, Kalshi, and Limitless that this framework’s detection and validation phases require, removing the need to build cross-venue normalization from scratch.