Building a Prediction Market Arbitrage Bot: Technical Implementation

---

Academic research documented $40 million in arbitrage profits extracted from Polymarket between April 2024–April 2025.[1] The opportunity persists because retail-dominated orderbooks lack institutional market-making infrastructure. Here’s the technical implementation for capturing structural mispricings.

The Structural Inefficiency

Prediction markets exhibit chronic pricing failures exploitable through systematic strategies.

Single-condition arbitrage: When YES + NO token prices deviate from $1.00, profit is guaranteed. Research analyzed 86 million bets across 17,218 conditions.[1] When sum-price falls below $1.00, arbitrageurs buy both positions and realize guaranteed profit at resolution.

Cross-platform fragmentation: Kalshi captured 62% of prediction market volume during September 11–17, 2025, processing $500+ million weekly with $189 million average open interest.[2] Polymarket accounted for 37% during the same period.[2] Material price divergences between platforms create cross-venue arbitrage opportunities.

Mispricings cluster during volatility events — polling releases, debate nights, economic data. Price discovery lags real-world information by minutes to hours. Top arbitrageur generated $2.01 million across 4,049 transactions.[1] Strategy requires execution frequency over position size.

System Architecture

API Integration

Polymarket operates a hybrid-decentralized Central Limit Order Book (CLOB) on Polygon (Chain ID 137).[3] Off-chain matching, on-chain settlement via conditional token framework.

from py_clob_client.client import ClobClient
from web3 import Web3
import asyncio
import websockets
import json

class ArbitrageMonitor:
    def __init__(self, private_key: str):
        self.host = “https://clob.polymarket.com”
        self.chain_id = 137
        self.w3 = Web3(Web3.HTTPProvider(’https://polygon-rpc.com’))
        
        # Initialize CLOB client
        self.client = ClobClient(
            self.host,
            key=private_key,
            chain_id=self.chain_id
        )
        
    async def monitor_markets(self, market_ids: list):
        “”“Real-time WebSocket monitoring”“”
        ws_url = f”{self.host}/ws/market”
        
        async with websockets.connect(ws_url) as ws:
            subscribe_msg = json.dumps({
                “type”: “subscribe”,
                “markets”: market_ids
            })
            await ws.send(subscribe_msg)
            
            async for message in ws:
                data = json.loads(message)
                await self.process_update(data)

Kalshi integration: REST API with tiered rate limits. Basic tier: 20 requests/second (read), 10 requests/second (write). Premier tier: up to 100 requests/second.[4] Implement per-second throttling with token bucket algorithm.

Mispricing Detection

from decimal import Decimal
from typing import Optional, Dict

def detect_single_condition_arbitrage(
    yes_price: Decimal,
    no_price: Decimal,
    liquidity: Decimal,
    min_profit: Decimal = Decimal(’0.05’),
    max_capital: Decimal = Decimal(’10000’)
) -> Optional[Dict]:
    “”“
    Identify YES+NO≠$1 opportunities
    Returns None if below profitability threshold
    “”“
    sum_price = yes_price + no_price
    
    # Long arbitrage: Buy both if sum < $1
    if sum_price < (Decimal(’1.00’) - min_profit):
        profit_per_dollar = Decimal(’1.00’) - sum_price
        position_size = min(liquidity, max_capital)
        
        return {
            ‘type’: ‘buy_both’,
            ‘yes_price’: yes_price,
            ‘no_price’: no_price,
            ‘position_size’: position_size,
            ‘expected_profit’: profit_per_dollar * position_size,
            ‘roi’: profit_per_dollar / sum_price
        }
    
    # Short arbitrage: Sell both if sum > $1
    elif sum_price > (Decimal(’1.00’) + min_profit):
        profit_per_dollar = sum_price - Decimal(’1.00’)
        position_size = min(liquidity, max_capital)
        
        return {
            ‘type’: ‘sell_both’,
            ‘yes_price’: yes_price,
            ‘no_price’: no_price,
            ‘position_size’: position_size,
            ‘expected_profit’: profit_per_dollar * position_size,
            ‘roi’: profit_per_dollar / sum_price
        }
    
    return None

Research shows extreme outliers exist: one trader converted $0.02 into $58,983.36 exploiting severe mispricing where both YES/NO traded below $0.02.[1]

Order Execution: Managing Leg Risk

Critical constraint: Non-atomic execution. One position may fill while hedge fails, creating directional exposure.

class OrderExecutor:
    def __init__(self, client: ClobClient):
        self.client = client
        self.timeout = 5  # seconds
        
    async def execute_atomic_arbitrage(
        self,
        market_id: str,
        opportunity: Dict
    ) -> bool:
        “”“
        Execute both legs with timeout protection
        Cancel unfilled orders if partial fill occurs
        “”“
        try:
            # Place orders simultaneously
            yes_task = self.place_order(
                market_id, 
                ‘YES’,
                opportunity[’position_size’],
                opportunity[’yes_price’]
            )
            no_task = self.place_order(
                market_id,
                ‘NO’,
                opportunity[’position_size’],
                opportunity[’no_price’]
            )
            
            yes_order, no_order = await asyncio.gather(
                yes_task,
                no_task,
                timeout=self.timeout
            )
            
            # Verify both fills
            yes_filled = await self.check_fill_status(yes_order[’id’])
            no_filled = await self.check_fill_status(no_order[’id’])
            
            if yes_filled and no_filled:
                return True
            
            # Cancel unfilled leg, exit partial position
            await self.handle_partial_fill(yes_order, no_order)
            return False
                
        except asyncio.TimeoutError:
            await self.cancel_pending_orders(market_id)
            return False

Research data: 75% of matched orders execute within 950 blocks (~1 hour on Polygon).[1] Sub-5-second timeouts minimize leg risk.

Gas Optimization: Polygon Transaction Costs

Polymarket executes on Polygon. Gas fees compress net returns on small arbitrages.

from decimal import Decimal
from web3 import Web3

class GasOptimizer:
    def __init__(self, w3: Web3):
        self.w3 = w3
        self.matic_usd_price = self.fetch_matic_price()
        
    def estimate_transaction_cost(self, order_size: Decimal) -> Decimal:
        “”“
        Calculate total transaction cost
        Typical Polygon gas: 30-100 gwei
        “”“
        gas_price = self.w3.eth.gas_price
        gas_limit = 150000  # Standard CLOB order
        
        gas_cost_wei = gas_price * gas_limit
        gas_cost_matic = Decimal(gas_cost_wei) / Decimal(10**18)
        gas_cost_usd = gas_cost_matic * Decimal(str(self.matic_usd_price))
        
        # Polymarket: 0% platform fee (current)
        return gas_cost_usd
    
    def is_profitable_after_costs(
        self,
        expected_profit: Decimal,
        order_size: Decimal,
        min_roi: Decimal = Decimal(’0.02’)
    ) -> bool:
        “”“Minimum threshold: 2% net ROI after costs”“”
        total_cost = self.estimate_transaction_cost(order_size)
        net_profit = expected_profit - total_cost
        net_roi = net_profit / order_size
        
        return net_roi > min_roi

Position Tracking: Oracle Risk Management

Critical risk factor: Cross-platform arbitrage faces resolution divergence.

Polymarket uses UMA’s Optimistic Oracle with token-holder governance. March 2025 incident: whale with 5 million UMA tokens (25% of voting power) manipulated $7M market resolution on Ukraine mineral deal despite no formal agreement.[5] Largest winner netted $55,000; biggest loser forfeited $73,000.[5]

Kalshi operates under CFTC-regulated settlement mechanisms. Oracle mismatch can destroy cross-platform hedges.

from typing import Dict, List
from decimal import Decimal

class PositionTracker:
    def __init__(self):
        self.positions = {
            ‘polymarket’: {},
            ‘kalshi’: {}
        }
        
    def calculate_oracle_risk_exposure(self) -> Dict:
        “”“
        Flag positions with cross-platform oracle exposure
        “”“
        exposure = {
            ‘capital_deployed’: Decimal(’0’),
            ‘oracle_risk_positions’: []
        }
        
        for platform, positions in self.positions.items():
            for market_id, pos in positions.items():
                exposure[’capital_deployed’] += pos[’capital’]
                
                # Identify cross-platform hedges
                if self.has_cross_platform_hedge(market_id):
                    exposure[’oracle_risk_positions’].append({
                        ‘market’: market_id,
                        ‘exposure’: pos[’capital’],
                        ‘platforms’: self.get_hedge_platforms(market_id),
                        ‘risk_type’: ‘oracle_divergence’
                    })
        
        return exposure
    
    def has_cross_platform_hedge(self, market_id: str) -> bool:
        “”“Check if position exists across multiple platforms”“”
        platforms_with_position = [
            platform for platform, positions in self.positions.items()
            if market_id in positions
        ]
        return len(platforms_with_position) > 1

Mitigation strategy: Avoid cross-platform positions unless spread exceeds 15 cents — sufficient buffer to absorb potential oracle manipulation.

Alert Infrastructure

Top arbitrageurs executed 4,000+ transactions over 12 months.[1] Frequency matters more than per-trade size.

from dataclasses import dataclass
from decimal import Decimal
import asyncio
import time

@dataclass
class ArbitrageAlert:
    market_id: str
    platform: str
    opportunity_type: str
    expected_profit: Decimal
    roi: Decimal
    timestamp: float
    urgency: str

class AlertSystem:
    def __init__(self, notification_handler):
        self.handler = notification_handler
        self.min_profit = Decimal(’10.00’)  # $10 minimum
        
    async def process_opportunity(self, opp: Dict):
        “”“
        Filter and prioritize by profit potential
        High urgency: ROI > 10% or profit > $100
        “”“
        if not self.meets_criteria(opp):
            return
            
        alert = ArbitrageAlert(
            market_id=opp[’market_id’],
            platform=opp[’platform’],
            opportunity_type=opp[’type’],
            expected_profit=opp[’expected_profit’],
            roi=opp[’roi’],
            timestamp=time.time(),
            urgency=self.calculate_urgency(opp)
        )
        
        await self.handler.send(alert)
    
    def calculate_urgency(self, opp: Dict) -> str:
        “”“
        High: ROI > 10% or profit > $100
        Medium: ROI > 5% or profit > $50
        Low: Below thresholds but above minimum
        “”“
        if (opp[’roi’] > Decimal(’0.10’) or 
            opp[’expected_profit’] > Decimal(’100’)):
            return ‘high’
        elif (opp[’roi’] > Decimal(’0.05’) or 
              opp[’expected_profit’] > Decimal(’50’)):
            return ‘medium’
        return ‘low’

Deploy multi-threaded monitoring across 100+ active markets. Mispricings cluster during polling releases, debate nights, economic data prints.

P&L Analysis: Historical Extraction

Research findings from April 2024–April 2025 measurement period:[1]

Single-condition arbitrage:

• Buy both positions (sum < $1.00): $5.90M extracted

• Sell both positions (sum > $1.00): $4.68M extracted

• Total single-condition: $10.58M

Market rebalancing (multi-condition):

• Buy YES across conditions: $11.09M

• Buy NO across conditions: $17.31M

• Sell strategies combined: $4.88M

• Total market rebalancing: $28.99M

Combinatorial arbitrage (cross-market):

• 13 dependent market pairs identified during 2024 election cycle

• 5 pairs showed realized extraction: ~$95K total

• Cross-market opportunities significantly rarer than single-market

Total extracted: $39,587,585.02

Top 10 arbitrageurs captured $8.18M (21% of total).[1] Distribution confirms power law: sophisticated actors dominate.

Market Microstructure Analysis

Trading volume growth:

• Polymarket processed $3.7B total volume during 2024 U.S. election cycle[1]

• Weekly prediction market volume reached $2B+ by October 2025[6]

• Kalshi processed $500M+ weekly during peak periods[2]

Institutional capital influx:

• ICE invested $2B in Polymarket at $8B pre-money valuation (October 2025)[7]

• Signals professionalization of market infrastructure

• Parallel to early crypto exchange arbitrage before institutional market makers

Competitive dynamics:

• September 11–17, 2025: Kalshi 62% market share, Polymarket 37%[2]

• Politics markets: largest absolute profits

• Sports markets: higher opportunity frequency, lower per-trade margins

The window compresses as institutional capital enters. Early crypto arbitrage generated 1,000%+ returns before market makers professionalized infrastructure. Prediction markets follow identical trajectory.

Execution Constraints

Capital efficiency: Most conditions offer $50-$500 maximum profit at available liquidity. Scaling requires:

• Monitoring 100+ markets simultaneously

• Accepting 1–5% per-trade margins

• Deploying capital through frequency, not position size

Latency requirements: Information propagation lag creates 5–10 minute windows during volatility events. Sub-second execution required for high-frequency opportunities.

Regulatory risk: Massachusetts sued Kalshi September 2025 for allegedly operating unlicensed sports betting.[8] Over $1B in wagers January-June 2025, 75% sports-related volume.[8] Polymarket settled with CFTC in 2022, restructured operations.

Key Takeaway

Prediction market arbitrage is market microstructure exploitation — not outcome forecasting. The strategy requires:

Infrastructure:

• Real-time monitoring: WebSocket feeds across 100+ markets

• Execution speed: Sub-5-second order placement with atomic timeout protection

• Capital allocation: $10K-$50K per condition based on liquidity

• Risk management: Avoid oracle exposure; implement leg-risk controls

Profitability: Accept 1–5% returns per trade. Scale through frequency. Top performer: 4,049 transactions generating $2.01M ($496 average per trade).

Timeline: ICE’s $2B investment signals professionalization. Spread compression inevitable as institutional infrastructure deploys. Research captured peak inefficiency during 2024 election cycle — future returns require faster execution, larger capital, and more sophisticated cross-venue strategies.

Deploy now or wait for compressed spreads. The opportunity window follows crypto’s 2016–2018 trajectory: early arbitrageurs extract outsized returns before market makers eliminate structural inefficiency.

---

References

[1] Saguillo, O., Ghafouri, V., Kiffer, L., & Suarez-Tangil, G. (2025). “Unravelling the Probabilistic Forest: Arbitrage in Prediction Markets.” arXiv:2508.03474. IMDEA Networks Institute. https://arxiv.org/abs/2508.03474

[2] Rodriguez, F. (2025, September 20). “Kalshi Outpaces Polymarket in Prediction Market Volume Amid Surge in U.S. Trading.” CoinDesk. https://www.coindesk.com/markets/2025/09/20/kalshi-outpaces-polymarket-in-prediction-market-volume

[3] Polymarket Documentation. (2025). “CLOB Introduction.” https://docs.polymarket.com/developers/CLOB/introduction

[4] Kalshi API Documentation. (2025). “Rate Limits and Tiers.” https://docs.kalshi.com/getting_started/rate_limits

[5] Yahoo Finance. (2025, March 27). “Polymarket Suffers UMA Governance Attack After Rogue Actor Becomes Top-5 Token Staker.” https://finance.yahoo.com/news/polymarket-suffers-uma-governance-attack-101646076.html

[6] Yahoo Finance. (2025, October 21). “Prediction Markets Hit All-Time High of $2 Billion in Weekly Volume.” https://finance.yahoo.com/news/prediction-markets-hit-time-high-200142742.html

[7] Intercontinental Exchange. (2025, October 7). “ICE Announces Strategic Investment in Polymarket.” https://ir.theice.com/press/news-details/2025/ICE-Announces-Strategic-Investment-in-Polymarket/

[8] Campbell, A.J. (2025, September 12). “Massachusetts Attorney General Files Lawsuit Against Kalshi.” WBUR News. https://www.wbur.org/news/2025/09/16/massachusetts-kalshi-lawsuit-predictions-sports-wagering

Cover photograph: Brynn Who Likes Editing, public domain, via Wikimedia Commons.