Kalshi and Polymarket API: Matched Market Data per Call

Find the same event on Kalshi and Polymarket and see the price gap, in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to list the five active events that are on both Kalshi and Polymarket with the widest price gap, and give me a table with the question on each venue, both prices and the match confidence.

One prompt returns matched markets and their spread. 1 min setup · 8-20 hrs saved.

You want prediction market data for your agent: what a market is trading at on Kalshi, what the same question trades at on Polymarket, and how far apart the two are. The data is easy to read and hard to join, because each venue words its questions differently and neither shares an identifier with the other. This guide shows the quickest route, what came back when we ran it live on 2026-10-16, and the traps in the output. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to get Kalshi and Polymarket data through an API?

Monid. Install it once, add a key, and your agent calls prediction market endpoints with a few parameters and gets typed JSON back, with no second client to write and no account to set up at each venue.

• Pay per call. A matched-pairs call is billed at $0.024 (Verified 2026-10-16), and a market-list call on the BlockRun route at $0.00935 (Verified 2026-10-16). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills. Current prices are on the Monid tools page.
• One install, every API. The same key and balance call the prediction market endpoints and every other tool on Monid. Both venues sit behind it, so a question about Kalshi and a question about Polymarket are two calls on one balance, not two integrations. The prediction markets tools page lists them.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever the agent needs them. Your agent reads SKILL.md and learns the rest, so setup takes about a minute.

How do you get the same event from Kalshi and Polymarket in one call?

Call the matching endpoint. /prediction-market/matching/pairs from the provider surf returns each pair of markets that describe the same event on both venues, with both identifiers, both current prices and a spread, so the join is already done.

Monid fits this job because the hard step, deciding that two differently worded questions are one event, is part of the response and you pay only for the pages you read.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Inspect, then run one

monid inspect -p surf -e /prediction-market/matching/pairs
monid run -p surf -e /prediction-market/matching/pairs --query '{}'

Ask for the widest gaps

The input schema lists category, match_type, active_only, min_confidence, sort_by, order, limit and offset. This is the call we ran on 2026-10-16:

monid run -p surf -e /prediction-market/matching/pairs --query '{"limit":5,"sort_by":"spread_pct","active_only":true}'

It returned 5 pairs and reported 36 active pairs in total. Page through them with offset; each page is one billed call.

Or hand the whole job to an agent

Can you pull Kalshi and Polymarket data yourself with Python?

Yes, and for a single market it is an evening. You query each venue for the market you care about, read the price, and compare.

The cost is the join and the upkeep. The two venues share no key: Polymarket identifies a market by a condition_id and a token_id, long hex and numeric strings, and Kalshi uses a market_ticker such as KXBTC2026250-27JAN01-250000. To compare them you need a matcher that reads the question text, and the text differs. On 2026-10-16 one pair read "Will 1 Fed rate cut happen in 2026?" on Polymarket and "Will the Fed cut rates 1 times?" on Kalshi. A string-overlap rule scores those as related and also scores plenty of unrelated questions the same way, and both venues list and delist markets every day, so the matcher needs maintenance for as long as you use it.

The Monid route is the choice for anything you will run more than once. The matcher is maintained for you, each pair carries a confidence and a match_type, and the prices and spread arrive in the same record.

What does prediction market data look like, and what can you build with it?

A prediction market record is a question, a price between 0 and 1 for each outcome, and the activity behind that price. We ran three endpoints on 2026-10-16, so the fields below are what came back.

The matched pair

{ "confidence": 100, "match_type": "exact", "category": "economics",
  "polymarket": { "condition_id": "0x5e08...", "outcome_label": "Yes",
                  "question": "Will 1 Fed rate cut happen in 2026?",
                  "event_slug": "how-many-fed-rate-cuts-in-2026",
                  "volume_usd": 1242646.44, "is_active": true },
  "kalshi": { "market_ticker": "KXRATECUTCOUNT-26DEC31-T1",
              "title": "Will the Fed cut rates 1 times?",
              "event_ticker": "KXRATECUTCOUNT-26DEC31",
              "volume_contracts": 1233355, "open_interest": 463927, "status": "active" },
  "polymarket_price": 0.014, "kalshi_price": 0.04, "spread_pct": 96.2963 }

Prices are probabilities: 0.04 means the market implies a 4 percent chance. The event_ticker is the real-world question and the market_ticker is one tradeable outcome within it. In this response the three Fed rate cut markets (0, 1 and 2 cuts) share the event KXRATECUTCOUNT-26DEC31, so aggregating at the wrong level counts one event three times.

The full market record from each venue

The BlockRun routes return the whole catalogue record rather than a pair. A Kalshi market came back with 30 top-level fields, including ticker, event_ticker, a market_id UUID, status, result, open_time, close_time, settlement_time, last_price, volume, open_interest, dollar_volume, dollar_open_interest, an outcomes list with bid and ask, and a series object that names the settlement sources, for example ESPN and Fox Sports on a Super Bowl market. A Polymarket market came back with 22 fields, including condition_id, market_slug, title, winning_side, total_volume_usd, liquidity_usd, tags, is_neg_risk and a description that holds the resolution rules in plain text.

What you can build with it

• A spread watcher. Sort by spread_pct, keep only active pairs at full confidence, and alert when a gap passes your threshold. The agent prompt at the top of the page is the whole job.
• A resolution-wording check. Pull the description of the Polymarket side and the series.settlement_sources of the Kalshi side and put them next to each other before anyone treats a gap as an opportunity.
• A research set. Join the two venues on condition_id and market_ticker, then store prices over time. The price series and daily comparison endpoints in the endpoint table below are made for it.

The same per-call pattern works for other market data: Insider Trading API: Pull SEC Form 4 Data for Any Company pulls filings for a ticker the same way.

What goes wrong when you compare prediction markets across venues?

Four things showed up in the 2026-10-16 runs, and each one changes how you read a gap.

Why is spread_pct not a measure of money?

Because it is relative to the price, so tiny prices produce huge percentages. The widest pair in our call showed 96.3 percent: Polymarket at 0.014 and Kalshi at 0.04. That is a gap of 0.026, or 2.6 cents on a one-dollar contract. On all five rows spread_pct matched the gap divided by the average of the two prices, times 100. The narrowest row was 0.964 against 0.95, a gap of 0.014, about half the widest row's 0.026, and a spread of 1.46 percent. Sort by spread_pct and you find the cheapest outcomes, not the largest differences. Compute the absolute gap yourself:

gap = abs(pair["polymarket_price"] - pair["kalshi_price"])
rel = gap / ((pair["polymarket_price"] + pair["kalshi_price"]) / 2) * 100
if gap >= 0.03 and pair["confidence"] == 100:
    flag(pair)

Why is a confidence of 95 worth reading?

Because the pairs that look similar are not always the same bet. Two of our five rows came back at confidence 95. One was match_type: "related": Polymarket asked "Will Reza Pahlavi enter Iran by December 31?" under an event slug ending in june-30, and Kalshi asked "Will Reza Pahlavi visit Iran before Jan 1, 2027?". Enter and visit are different words and the dates are written differently. The other was marked exact and still differed in wording: Polymarket asked whether Bitcoin will reach 250,000 dollars by December 31, 2026, and Kalshi asked whether it will be above that level on Jan 1, 2027 at 12:00AM ET. Touching a level at any time and being above it at one moment are different outcomes, so the prices are allowed to differ. Treat anything below 100, and anything marked related, as a lead to read by hand.

Why can you not compare the volume fields directly?

Because they are in different units. The pair record reports Polymarket volume_usd in dollars and Kalshi volume_contracts in contracts. The Fed pair above shows 1,242,646 on one side and 1,233,355 on the other, which look the same size and are not the same thing. The input description for the daily comparison endpoint says the same: Polymarket is USD, Kalshi is contracts. The BlockRun Kalshi route adds a dollar_volume field, and on all five markets we pulled it was exactly half of volume (rounded down), so a conversion has been applied for you on that route. Compare dollars with dollars.

# wrong: dollars minus contracts
gap = pair["polymarket"]["volume_usd"] - pair["kalshi"]["volume_contracts"]

# right: use the route that reports dollars, or compare each venue with its own history

Why does the first page of a market list look old?

Because the default order is by volume and the biggest markets are the settled ones. Both BlockRun list calls returned five markets with status: "closed": a 2026 World Cup winner market and a Super Bowl market on Kalshi, and the 2024 presidential election on Polymarket at total_volume_usd 1,636,188,222. The responses carried a pagination_key and has_more: true. For live markets use the matching endpoint with active_only, or the search endpoint, whose input lists a status filter that defaults to active. On the settled Polymarket rows liquidity_usd was 0, which is true of a closed market and meaningless as a liquidity reading.

Our three runs cost $0.0427 in total (Verified 2026-10-16): one pairs call at $0.024 and two list calls at $0.00935 each. A hundred pairs calls is about $2.40.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. We ran the first row and the last two. The other rows were inspected and not run, so the table describes their inputs and not their output. Start with the matching endpoint for anything cross-venue, the search endpoint to find a ticker or slug, and the BlockRun routes when you want the full record for a single venue.

When is another route a better fit?

You need a stream. Each call is a snapshot. The matching endpoint's description gives a data refresh of about 5 minutes, so it suits watching a gap through the day, not reacting to news in seconds. Anything that has to move on a tick needs a live feed from the venue.

You need to place trades. These are read endpoints. Placing an order is a different integration, with the venue's own account and rules, and not part of this data.

You need years of history in bulk. A price series endpoint returns a window of up to a year per call, and a research project that wants every market since launch is better served by a downloadable dataset than by thousands of paid calls; dataset versus API covers that fork for another kind of data.

And the disclosure: we resell these endpoints, including the matcher. The most useful thing in this post is that you should compute the absolute gap yourself, read the wording of any pair below confidence 100, and keep dollars apart from contracts, and that holds whichever data source you use.

Conclusion

The quickest way to get Kalshi and Polymarket data into an agent is through Monid: the matching endpoint at $0.024 a call (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. Writing two clients and a matcher yourself works for a single market and costs hours of joins and upkeep; Monid keeps the matcher maintained.

Two things matter more than the endpoint you pick. A big spread_pct on a tiny price is a rounding story, so compute the absolute gap. And a pair below confidence 100, or marked related, is two bets with different wording until you have read both sets of rules.

How we estimated the time saved: building and testing a matcher for two venues, with identifiers and fuzzy question rules, is roughly 6 to 12 hours, plus 2 to 8 hours to map fields and keep units straight. That is 8 to 20 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p surf -e /prediction-market/matching/pairs, then make one call with limit set to 5 and read the two question texts side by side. Start at monid.ai.

FAQ

Published September 2026.