Is Prediction Market Arbitrage Worth It

Prediction market arbitrage looks like the easiest trade in finance. Two venues price the same event differently, you buy both sides, the outcome pays 100¢ whatever happens, and you keep the difference.

The idea is sound. The arithmetic on the screenshot is not, because those numbers are midpoints and nobody trades at a midpoint.

What does prediction market arbitrage actually pay?

It pays whatever is left of the gap after both spreads, both fee schedules and the cost of holding capital until resolution, and on most markets that remainder is zero or negative.

The trade itself is simple: buy YES on one venue and NO on another. If both contracts settle on the same event, one pays 100¢ and the other pays nothing, so any pair bought under 100¢ leaves you the difference.

Gaps that genuinely survive are 1¢ to 4¢ wide. On 100 USD of exposure that is 1 to 4 USD before fees, and the money is locked until the event resolves. A 3¢ gap resolving next week beats the same 3¢ gap resolving in eleven months.

Depth sets the rest. A 4¢ gap with 30 USD behind it pays about 1.20 USD.

Why is most prediction market arbitrage not real?

Because the price you are comparing is a midpoint, and a midpoint is not an ask. It averages a bid you cannot buy at with an ask you can.

Across 5,000 live Kalshi markets on 2026-09-03, reproducible from the public Kalshi API with no key, Predictefy found 18.1% of markets had no bid at all. On those markets the displayed midpoint is a number the venue computed, not a price anyone was offering. The median spread where two sides existed was 5.1¢.

That kills most published opportunities: if two venues disagree by 3¢ and crossing one book costs 5.1¢, the gap was gone before you clicked.

Spread tracks how busy the market is.

The share of markets quoting inside 2¢ rises from 7% in the quietest bucket to 69% in the busiest. The widest books were scalar economic markets, KXUSCPIYEAR at 57¢ and KXFEDFUNDSYEAR at 42¢. The tightest were sports, KXWC at 0.3¢.

Read that as a map. Long-dated economic markets show the biggest apparent gaps and almost none are real. Sports books are where real gaps live, and where they close in seconds.

How much does the spread eat from an arbitrage gap?

Enough to flip a winning screenshot into a losing trade. Here is one opportunity priced two ways, using the measured 5.1¢ median spread.

Nothing unusual happened here. Each leg was quoted with roughly half the median spread on its side, the ordinary case rather than the bad one.

This is why honest tooling qualifies candidates against live order books instead of midpoints. A scanner ranking by midpoint difference is really ranking by illiquidity.

How much time does prediction market arbitrage take?

Discovery takes minutes and integration takes weeks, which is the part nobody budgets for.

By hand you open several venues, match a market on one to a market on another, read two order books, convert price conventions, then start over because the book moved. Most of an evening produces a handful of candidates, most dead on arrival.

Building it yourself means a separate integration per venue: different authentication, identifiers, tick sizes and ways of expressing the same YES contract, all maintained as each venue ships changes.

The trade is simple, the plumbing is not, and the plumbing decides whether you see a 2¢ gap while it exists or ten minutes after it closed.

What makes a prediction market arbitrage worth trading?

Five conditions, and a candidate has to pass all five, not most of them.

Resolution equivalence is the one people skip. Contracts with near identical titles can settle differently on edge cases, and the edge case is exactly where a wide gap comes from.

Execution risk is the one you cannot engineer away. Predictefy does not run a cross-venue smart order router: each leg is built and submitted on its own venue, so the two fills are never simultaneous.

How do you find prediction market arbitrage without checking every venue by hand?

You read every venue through one schema, then qualify each candidate against the live book. Predictefy covers 15+ venues, the widest coverage of any cross-venue scanner, and the arbitrage API is free on every plan including the 0 USD tier.

The clients are available in beta: @predictefy/sdk 1.0.0-beta.6 and @predictefy/mcp 1.0.0-beta.6 on npm, predictefy 1.0.0b4 on PyPI. The MCP server runs with npx -y @predictefy/mcp under an MIT license, and no MCP tool both builds and submits an order. Reads go to https://data.predictefy.com behind an Authorization: Bearer pk_live_ header.

// Reads API: https://data.predictefy.com, one path shape per venue,
// /api/{venue}/{verb}. Free tier: 25,000 credits a month, 60 requests a minute.
const API = 'https://data.predictefy.com';
const KEY = process.env.PREDICTEFY_API_KEY;        // pk_live_...
const VERB = '<order-book-verb-from-the-api-docs>';

function read(venue) {
  return fetch(API + '/api/' + venue + '/' + VERB, {
    headers: { Authorization: 'Bearer ' + KEY }
  }).then(function (res) { return res.json(); });
}

// Ask ladder from one response, as [[price, size], ...]. Match these two
// field names to the response documented for VERB.
function toLadder(payload) {
  return payload.asks.map(function (level) { return [level.price, level.size]; });
}

// Average price per contract to fill `size`, walking the asks. Returns
// Infinity when the ladder cannot fill the whole order, so a thin book
// fails the test below instead of passing on one lucky contract.
function avgFillCost(asks, size) {
  let left = size;
  let spent = 0;
  for (const [price, available] of asks) {
    const take = Math.min(left, available);
    spent += take * price;
    left -= take;
    if (left === 0) return spent / size;
  }
  return Infinity;
}

// One pair: buy YES on one venue, NO on the other.
async function qualify(venues, size) {
  const ladders = await Promise.all(venues.map(function (venue) {
    return read(venue).then(toLadder);
  }));

  // Midpoints are not asks. Price the size you intend to trade.
  const perPair = ladders.reduce(function (sum, asks) {
    return sum + avgFillCost(asks, size);
  }, 0);

  if (!Number.isFinite(perPair)) return null;   // not enough depth to fill
  if (perPair >= 1) return null;                // the spread ate the gap

  return perPair;                               // cost per pair, under 1.00
}

qualify(['kalshi', 'polymarket'], 100).then(function (cost) {
  console.log(cost === null ? 'no trade' : 'clears at ' + cost.toFixed(4));
});

Execution is a separate non-custodial service, per venue, at /v1/exec/{venue}/orders/. Building an order is unmetered, submit, cancel and modify charge credits, and every write requires an Idempotency-Key. Orders are signed client side, the hosted read layer holds no venue credentials and never sees them, and stored history is proven across all 16 served venues.

Is prediction market arbitrage worth it?

It is worth it if you can automate the reading and stay honest about size. It is not worth it as a manual side project, because the gaps slow enough to find by hand are the ones the spread has already eaten.

The execution caps make the shape clear: 100 USD per order, 1,000 USD per key per rolling 24 hours. That is a system for capturing many small verified gaps, not a fortune bet on one screenshot.

The free tier gives 25,000 credits a month, 60 requests a minute, 1 API key and 2 WebSocket streams, enough to learn your own hit rate before paying anything. Builder is 49 USD a month, Pro is 249 USD, Scale is 999 USD, Enterprise from 2,500 USD.

So the verdict splits. Earning a few percent on locked capital, with real execution risk, on the small share of gaps that survive contact with the order book, yes. Printing money from midpoint differences on illiquid markets, no, and the 18.1% no-bid figure is the reason.

Frequently Asked Questions