How to Find Cross-Platform Arbitrage Opportunities Between Kalshi and Polymarket

Kalshi and Polymarket frequently list contracts tied to the same election, sports result, economic release, crypto event, or geopolitical outcome.

Those markets do not always agree on price.

Polymarket may offer the cheaper YES position while Kalshi offers the cheaper NO position. The reverse can also happen. When the combined executable cost is below the contracts' fixed combined payout after fees, a cross-platform arbitrage candidate exists.

The arithmetic is simple. The difficult parts are market matching, order-book normalization, fee handling, trade sizing, and revalidation.

Predictefy handles much of that fragmented infrastructure through one normalized prediction market layer, allowing traders and developers to focus on the opportunity rather than maintaining separate Kalshi and Polymarket integrations.

How Kalshi and Polymarket Arbitrage Works

Both platforms offer binary contracts whose payouts depend on whether an event occurs.

A cross-platform arbitrage strategy attempts to acquire complementary outcomes for less than their combined settlement payout.

Route A:
Polymarket YES ask
+ Kalshi NO ask
+ applicable fees
< $1.00

Route B:
Kalshi YES ask
+ Polymarket NO ask
+ applicable fees
< $1.00

Suppose the executable prices are:

Polymarket YES: $0.42
Kalshi NO:      $0.54

Combined cost: $0.96
Combined payout: $1.00
Gross edge: $0.04
Gross ROI: 4.17%

The same calculation fails if the markets are not true complements.

A Polymarket contract asking whether a candidate wins an election is not equivalent to a Kalshi contract asking whether that candidate wins the popular vote. Likewise, a market resolving by December 31 is not automatically interchangeable with one that remains open through inauguration.

Find Matching Markets Before Comparing Prices

Market matching is usually the hardest part of Kalshi and Polymarket arbitrage.

Titles alone are unreliable. One venue may use a short ticker-style question while the other uses a broader event page with multiple outcomes. Even when the wording appears identical, the detailed rules can differ.

Predictefy's matching engine groups equivalent cross-venue markets into clusters and exposes indicative price discrepancies between cluster members.

The discrepancy layer is useful for discovering where Kalshi and Polymarket disagree:

const discrepancies =
  await client.fetchDiscrepancies({
    live: true
  });

console.log(discrepancies);

Predictefy deliberately keeps this discovery layer separate from its executable-arbitrage layer.

Qualify Kalshi and Polymarket Arbitrage With Predictefy

Once matching markets have been identified, the next step is to price the actual trade.

Predictefy's TypeScript SDK exposes one typed client for venue-specific data and a router for cross-venue operations.

Install the official SDK:

npm install @predictefy/sdk

Create an authenticated client:

import Predictefy from '@predictefy/sdk';

const client = new Predictefy({
  apiKey: process.env.PREDICTEFY_API_KEY
});

Request executable cross-venue opportunities:

const opportunities =
  await client.router.fetchArbitrage({
    contracts: 100,
    executableOnly: true
  });

Keep only Kalshi–Polymarket pairs:

function isKalshiPolymarket(row) {
  const venues = [
    row.legs?.buyYes?.venue,
    row.legs?.buyNo?.venue
  ];

  return (
    venues.includes('kalshi') &&
    venues.includes('polymarket')
  );
}

const kalshiPolymarketArbs =
  opportunities.filter(isKalshiPolymarket);

The REST equivalent is:

curl --request GET \
  --url 'https://data.predictefy.com/api/router/fetchArbitrage?contracts=100&executableOnly=true&limit=10' \
  --header 'Authorization: Bearer pk_live_YOUR_KEY'

Predictefy only applies the arbitrage label when every required gate passes.

Useful response fields include label, executable, contracts, the two trade legs, VWAP, fees, total cost, payout, net edge, ROI, freshness, and machine-readable rejection reasons.

Compare Order-Book Depth, Fees, and Trade Size

Kalshi and Polymarket do not expose their native books in the same format.

Polymarket assigns a separate token ID to each outcome and exposes resting bids and asks for that token.

Kalshi's native order-book response contains YES bids and NO bids. The opposite-side bids imply asks: the best YES ask equals $1 minus the best NO bid, while the best NO ask equals $1 minus the best YES bid.

Predictefy normalizes both venues into a consistent bids-and-asks structure.

You can inspect both normalized books through the same SDK:

const [polymarketBook, kalshiBook] =
  await Promise.all([
    client.polymarket.fetchOrderBook({
      outcomeId: 'POLYMARKET_OUTCOME_ID'
    }),
    client.kalshi.fetchOrderBook({
      outcomeId: 'KALSHI_OUTCOME_ID'
    })
  ]);

console.log(polymarketBook.asks);
console.log(kalshiBook.asks);

Do not use the best ask as the price for the entire trade.

Suppose the cheaper YES leg has 20 contracts at 42 cents, 100 at 45 cents, and 500 at 48 cents. A 20-contract trade and a 500-contract trade have different average execution prices.

A practical strategy should test more than one size:

for (const contracts of [25, 100, 500]) {
  const rows =
    await client.router.fetchArbitrage({
      contracts,
      executableOnly: true
    });

  const matches =
    rows.filter(isKalshiPolymarket);

  console.log({
    contracts,
    opportunities: matches.length
  });
}

Fees must also be evaluated dynamically.

Polymarket charges taker fees on certain market categories, while other categories may be fee-free. Kalshi states that fees can vary between markets and that maker fees may apply in some cases.

Do not use a universal zero-fee assumption for either platform.

Monitor, Revalidate, and Manage Execution Risk

A valid opportunity can disappear between detection and execution.

Predictefy exposes its cross-venue arbitrage surface over WebSocket through the SDK's watchArbitrage() helper.

const close = client.watchArbitrage(
  ({ frame }) => {
    const candidates =
      frame.rows.filter(isKalshiPolymarket);

    for (const row of candidates) {
      console.log({
        question: row.question,
        executable: row.executable,
        netEdge: row.netEdge,
        roi: row.roi,
        reasons: row.reasons
      });
    }
  },
  {
    onError: (error) =>
      console.error(
        error.code,
        error.message
      )
  }
);

// later:
// close();

Before entering an order workflow, re-run the live assessment at the same trade size:

async function revalidate(candidate, contracts) {
  const latest =
    await client.router.fetchArbitrage({
      contracts,
      executableOnly: true
    });

  return latest.find((row) =>
    row.clusterId === candidate.clusterId &&
    isKalshiPolymarket(row)
  ) ?? null;
}

The remaining risks should be managed explicitly.

Cross-platform prediction market arbitrage is therefore not automatically risk-free. The intended payoff can be covered once both compatible positions are successfully obtained, but the process of reaching that state carries execution, venue, and settlement risk.

Frequently Asked Questions

Conclusion

Finding cross-platform arbitrage between Kalshi and Polymarket requires more than identifying two prices that sum below $1.

The contracts must describe the same outcome. Their deadlines, thresholds, resolution sources, and edge-case rules must align. Both books need enough executable depth, and the spread must remain positive after current fees.

You can build separate Kalshi and Polymarket integrations, reconstruct their different order-book formats, create your own market matcher, and maintain the cross-venue qualification logic yourself.

Predictefy provides a shorter path.

Use matched markets and discrepancies to identify where the venues disagree. Use client.router.fetchArbitrage() to assess the complementary trade at the exact size you want. Use normalized order books when your strategy needs deeper inspection, and use watchArbitrage() for continuous monitoring.

Then keep your own strategy responsible for position sizing, capital limits, revalidation, and execution policy.

Predictefy handles the fragmented Kalshi and Polymarket infrastructure. Your strategy decides which qualified opportunities are worth pursuing.

This article is for general informational and engineering purposes and is not financial, investment, or legal advice.