Prediction Market Arbitrage Guide: How to Profit From Cross-Platform Price Gaps

Prediction market arbitrage is one of the few strategies that can generate risk-free profit. When the same event trades at different prices on Kalshi and Polymarket, you can lock in a guaranteed return by buying the cheaper side and selling the expensive one. This guide walks through exactly how it works, how to calculate your edge, and the tools you need to execute consistently.

What is prediction market arbitrage?

Arbitrage exploits price differences for the same outcome across different markets. In prediction markets, each contract settles at either $1.00 (Yes) or $0.00 (No). When Platform A prices an event at 55 cents and Platform B prices the same event at 62 cents, the gap creates an opportunity.

The core principle: if the sum of the cheapest Yes and cheapest No prices across platforms is less than $1.00, you have a risk-free arbitrage. You buy both sides cheaply, and no matter what happens, one side pays out $1.00.

Traditional finance has had arbitrage for decades. Prediction markets are newer, less efficient, and fragmented across platforms — meaning gaps appear more often and persist longer than in equities or forex.

How arbitrage works: a concrete example

Let's say the event is "Will the Fed raise rates at the June 2026 meeting?" and you see these prices:

Here's the play:

• Buy Yes on Polymarket: $0.55 per contract
• Buy No on Kalshi: $0.38 per contract
• Total cost: $0.55 + $0.38 = $0.93
• Guaranteed payout: $1.00 (one side always wins)
• Profit per contract: $1.00 − $0.93 = $0.07
• Return: $0.07 / $0.93 = 7.5%

With 100 contracts on each side, you invest $93 and receive $100 regardless of the outcome. That's $7 profit with zero directional risk. Scale to 1,000 contracts and you're looking at $70 locked in.

The key insight: you don't need to predict the outcome. You profit from the price discrepancy, not the event itself.

Types of prediction market arbitrage

Not all arbitrage is the same. Here are the three main categories:

Cross-platform arbitrage

The most straightforward type. The same binary event trades on two or more platforms at different prices. You buy the cheap Yes on one platform and the cheap No on the other. This is what the example above demonstrates. It works because Kalshi and Polymarket have different user bases, different liquidity pools, and different information flows. For a deeper look at how Polymarket's order book creates these gaps, see our Polymarket order book guide.

Correlated-market arbitrage

Some events are logically linked. For example, if "Democrats win the Senate" is priced at 60% but the sum of all individual Senate race probabilities implies only a 52% chance of a Democratic majority, the aggregate market is mispriced relative to the components. This requires modeling — you're not just comparing two prices, you're computing implied probabilities from multiple markets and finding inconsistencies.

Time-based arbitrage

Markets react to news at different speeds. When a major economic report drops, Polymarket (with its on-chain order book) might reprice within seconds, while Kalshi's central limit order book takes longer for market makers to update. The window is short — often under 60 seconds — but if you have fast data feeds and pre-funded accounts, you can capture the stale price before it adjusts.

Step-by-step guide to finding arbitrage

Here's the systematic process professional arbitrageurs follow:

• Step 1 — Map equivalent markets: Build a list of events that trade on both Kalshi and Polymarket. Focus on high-profile events (elections, Fed decisions, economic data releases) since these have the most liquidity. Check that settlement criteria are identical — even small differences in contract wording can mean they're not truly the same bet.
• Step 2 — Pull real-time prices: Use the Kalshi API and Polymarket's CLOB API to stream live quotes. You need best bid and best ask on both sides, not just mid-prices. The arbitrage exists at the executable price, not the indicative price.
• Step 3 — Calculate the spread: For each matched pair, compute: Cheapest Yes + Cheapest No across platforms. If this sum is below $1.00 (minus fees), you have an opportunity.
• Step 4 — Check liquidity: A 7-cent spread means nothing if the order book only has $50 of depth at that price. Check available size at the arb price on both platforms. You need enough volume on both sides to make the trade worthwhile after fees.
• Step 5 — Execute simultaneously: Place both orders as close to simultaneously as possible. Every second of delay is a risk that one side fills and the other moves. Use API-based order placement for speed.
• Step 6 — Monitor and wait for settlement: Once both sides are filled, the hard work is done. Hold until the event resolves. One side pays $1.00, the other pays $0.00, and you collect your profit.

Calculating profit: formulas and examples

The basic arbitrage profit formula is:

Profit = $1.00 − (Best Yes Price + Best No Price) − Total Fees

Let's work through a detailed example with fees included:

At 500 contracts per side, that's $465 invested and $485 returned — a $20 profit for zero directional risk. Not life-changing on a single trade, but arbitrageurs run dozens of these per week. Over a year, even small edges compound into meaningful returns.

For correlated-market arbitrage, the calculation is more complex. You need to build a probability model and compare the model's implied probability against the market price. If your model says an event has a 70% chance but the market prices it at 60%, you have a 10-cent expected edge per contract. This isn't risk-free — your model could be wrong — but if your model is calibrated, it's profitable over a large sample.

Tools you need

Successful arbitrage requires the right infrastructure:

• API access: Both Kalshi and Polymarket offer REST and WebSocket APIs. You need programmatic access to stream prices and place orders. Manual trading is too slow for most arb windows. See our Kalshi API tutorial for setup instructions.
• Price monitoring dashboard: A real-time display showing matched markets with current spreads. Alphascope's arbitrage scanner does this automatically.
• Pre-funded accounts: You need capital sitting on both platforms, ready to deploy. If you have to deposit and wait for confirmation, the opportunity will be gone.
• Execution scripts: Python or TypeScript scripts that can fire orders on both platforms within milliseconds of each other. Latency matters.
• Spreadsheet or tracker: Record every trade, including entry prices, fees, settlement outcome, and net P&L. This is how you verify your edge is real and not eroded by costs you overlooked.

Risks and limitations

Arbitrage in prediction markets is lower risk than directional trading, but it's not zero risk. Here are the real dangers:

• Execution risk: The biggest one. You fill on Platform A but the price moves on Platform B before your order executes. Now you have a one-sided position — you wanted an arb but got a directional bet. Mitigation: use limit orders on both sides and cancel if one doesn't fill within seconds.
• Settlement differences: Kalshi and Polymarket may define the same event differently. "Will GDP growth exceed 3%?" could reference different GDP measures, different revision dates, or different rounding rules. Always read the full contract specification on both platforms.
• Fee drag: A 7-cent gross spread can shrink to 2 cents after fees. Kalshi charges a fee on winning contracts (typically 1-2%), and Polymarket has taker fees around 1%. Always model net-of-fees returns.
• Capital lockup: Your money is locked from trade entry until settlement. An event three months away means your $1,000 arb position ties up capital for 90 days. A 4% return over 3 months is only ~16% annualized — decent but not spectacular once you factor in opportunity cost.
• Platform risk: Regulatory changes, exchange outages, or withdrawal delays can affect your ability to collect. Diversify across platforms and avoid concentrating too much capital on any single exchange.
• Liquidity illusion: Displayed order book depth can vanish in volatile moments. A market showing $5,000 of depth might have only $500 of firm liquidity when a major news event hits.

Advanced: market-making basics

Market-making is arbitrage's more active cousin. Instead of waiting for cross-platform gaps, you provide liquidity by posting bids and offers on the same market and profiting from the spread.

Here's a simplified example on a single platform:

• Post a bid at $0.48 (willing to buy Yes)
• Post an offer at $0.52 (willing to sell Yes)
• If both fill: You bought at 48 and sold at 52 = $0.04 profit per contract

The challenge is inventory management. If only your bid fills, you're now long the contract and exposed to price risk. Professional market makers use delta-hedging (offsetting on another platform) and position limits to manage this. They also adjust quotes dynamically based on order flow — if they see large buy orders, they widen their ask or move quotes higher.

Market-making requires significantly more capital, faster systems, and deeper expertise than simple cross-platform arbitrage. Start with basic arb and progress to market-making as you build experience and infrastructure. For background on how order books work in these markets, see our Polymarket order book explainer.

Spot arbitrage with Alphascope

Alphascope monitors prediction markets in real-time to find profitable opportunities:

• News → Breaking news linked to market-moving events
• Predictions → AI analysis of mispriced markets
• Arbitrage → Live cross-platform price gap alerts