Prediction markets are casinos for the mathematically illiterate and gold mines for the sharp. You aren't trading assets here—you're trading probabilities of future outcomes. Arbitrage is the only reliable way to extract systematic edge, completely ignoring the noise of the news cycle.
Spread hunting math
Arbitrage on platforms like Polymarket or Kalshi comes down to hunting mispriced odds where the combined cost of "Yes" and "No" shares doesn't equal 1. If you buy the total outcome for $0.95 and the payout is $1.00, you're locking in a 5.2% return. It’s a "risk-free" trade, provided you don't get wrecked by execution failure (leg risk).
Real-world profit formula:Net Profit = (1 - Price_Yes - Price_No) - (Taker Fees + Network Gas)
If your net percentage is below 2%, you're just burning cash on gas and wasting your own compute cycles.
Bot architecture
Forget the web UI. You need a local agent hitting the platform APIs directly. Here is a production-ready template in Python to pull the order book and calculate the delta.
import requests
import time
# Session init for speed
session = requests.Session()
def get_best_bid_ask(market_id):
"""
Fetch order book from Polymarket API
"""
url = f"https://clob.polymarket.com/orderbook/{market_id}"
response = session.get(url).json()
# Pull top-of-book prices
return float(response['bids'][0][0]), float(response['asks'][0][0])
def scan_arbitrage(market_yes, market_no):
# Grab Ask prices (what you pay to get in)
_, ask_yes = get_best_bid_ask(market_yes)
_, ask_no = get_best_bid_ask(market_no)
total_cost = ask_yes + ask_no
if total_cost < 0.96: # Accounting for 4% buffer (gas + slippage)
print(f"!!! ARB FOUND: {total_cost:.4f} !!!")
# Insert your wallet execution logic here
else:
print(f"Spread too tight: {total_cost:.4f}")
# Market ID example (swap for active events)
# scan_arbitrage('2187654321', '2187654322')
Hidden traps and industry jargon
- Resolution Delay: The ultimate pain point. The event happens, but the payout is locked in a UMA oracle dispute. Your capital stays frozen for 3 to 14 days. Arbitrage here is a game of revolving capital.
- Order Book Ghosting: Don't trust the surface liquidity. You see a $0.40 bid, but try to fill it and the price instantly jumps to $0.45. That's AMMs defending their spread.
- Cross-Platform Skew: Prices often drift between Kalshi and Polymarket because the demographic is different. Kalshi (US-based) is heavily hedged by political sentiment; Polymarket is crypto-degen territory. Watch the correlation: if BTC dumps, Polymarket moves seconds before Kalshi.
Operational efficiency matrix
| Scenario | Risk | Profitability | Verdict |
|---|---|---|---|
| Single-platform | Low | 1-2% | Waste of compute |
| Cross-platform | Medium | 3-7% | Bot sweet spot |
| Options hedging | High | 10%+ | Pro-only (requires serious bank) |
How to survive the first day
Rule #1: Stay out of low-volume markets. If liquidity is under $50k on either side, your entry will tank the price against you (slippage). Stick to events with $500k+ daily volume.
Pro-tip: If you're on Polygon/Polymarket, stop using default gas settings. You're racing MEV bots. Crank that maxPriorityFeePerGas. If you want the fill, you better be the first one in the next block.
Arbitrage isn't about finding the "Holy Grail"; it's about execution management. The winner isn't the guy who sees the gap first; it's the guy whose bot compiles the tx and hits the mempool fastest.
Anatomy of a losing strategy
Most scripts fail because they execute serially. You poll Polymarket, wait for the response, poll Kalshi, do the math, then fire the transaction. By then, the market makers—who are glued to WebSockets—have already eaten the alpha.
Professional approach:
- WebSockets over REST: Polling is legacy. Keep active sockets open to both order books. Real-time updates save you 200ms–800ms.
- Multicall/Batching: Don't send two separate transactions. Use a smart contract wrapper. Bundle both orders into a single call. If one side fails, the contract reverts everything. This kills "one-legged" trades where you get stuck long on one side and lose the arb.
Optimized execution (Solidity snippet)
If you're on EVM, delegatecall is your best friend. It executes the arb in one atomic unit.
// Conceptual bundle executor
function executeArbitrage(
address target,
bytes calldata data1,
bytes calldata data2
) external payable {
// Fire both legs in one atomic transaction
(bool success1, ) = target.call{value: msg.value / 2}(data1);
(bool success2, ) = target.call{value: msg.value / 2}(data2);
// Fail-safe: revert if arb isn't clean
require(success1 && success2, "Arbitrage execution failed - reverting");
}
"Event-Driven" alpha
Prediction market prices move based on external reality, not just inside the book.
- Leading Indicators: Hook your bot into news feeds (Bloomberg API or niche Telegram scrapers). Markets price in news 1–3 seconds before the bulk crowd reacts. Your job is to be positioned before the order book digests the headline.
- Synthetic Arb: Sometimes it's better to pair-trade against futures. If Polymarket shows a massive spike in probability but the corresponding index future hasn't budged, the prediction market is overheated. Short the prediction, buy the future. Hedge the gap until reality converges.
Pre-flight checklist
- Gas Benchmarking: Calc profitability at 50 Gwei vs 200 Gwei. If the arb barely covers 50 Gwei, and the chain is congested—turn the bot off.
- Slippage Hard-Limit: Never use Market Orders for arb. Use limit orders, set slightly above the best Ask. If the price moves, let it go. Missing a trade is better than a bad fill.
- Dirty Data: Don't trust "average price" columns in API responses. They're often lagged. Always parse asks/bids directly, ignore last_price.
Arbitrage isn't about luck; it's about grinding a mathematical edge. Keep the emotions at zero and the code optimized, and your USDC balance will outpace inflation.
