Kalshi Arbitrage Finder — Groups Priced Against $1

What it does: Prices each Kalshi event where at most one outcome can win as a whole group: what you get for selling one contract of every outcome, after Kalshi's fees.

You enter: Kalshi categories, e.g. Politics, Economics; or specific series tickers such as KXNEWPOPE.

You get: One row per group: money back from selling one contract of every outcome, profit % before and after fees (at one contract and at large size), cash tied up and return on it, outcomes priced and why any were not — from up to 200 open events scanned per run.

Price: $0.02 per group priced — a default run scans 200 open events and charges for every group it prices: 17 groups in the measured run (200 events, 3 categories), and it varies by category. +$0.002 per outcome if you also want each one (off by default). Groups that can't be priced, or that your minimum-profit setting drops, are never charged.

Example: enter series KXGDPYEAR → 11 open events read, 1 group priced (US real GDP growth in 2035, real run 2026-08-18): selling one contract of every outcome returns $0.86 · -14.0% before fees · -28.0% after fees at one contract · -19.6% at large size, the limit where the fee rounding washes out

Unofficial — not affiliated with Kalshi. Reads public pages only.

What you get, one row per group

A group here is a set of Yes/No markets on Kalshi that can't all happen: the exchange marks the event so that at most one of its outcomes can win. Each of those outcomes is a leg. This Actor prices the whole group at once — what you would get for selling one contract of every leg — and returns one row per group. In the data those rows are typed basket and the field names keep that word.

field	meaning
sumBestBid	proceeds from selling one contract of every leg
sellAllEdgePct	(sumBestBid - 1) x 100 — the gross locked-in edge
totalFeeUsd / sellAllEdgeNetPct	Kalshi's fee and the surviving edge at one contract — the conservative bound
totalFeeAtScaleUsd / sellAllEdgeNetAtScalePct	the same at large order size, where Kalshi's per-order cent rounding washes out
feeBasis	one sentence on why there are two figures and where the truth sits
maxCollateralUsd / returnOnMaxCollateralPct	capital actually at risk, and the return on it
collateralReturnType / collateralBasis	Kalshi's own margining flag for this event, and which basis the capital figure used
sumBestAsk	cost of buying every leg (a fact — see below)
legsTotal / legsPriced / legsUnpriceable	how much of the group was actually sellable
legsUnpriceableBreakdown	why each leg was dropped: no-bid, not-active, bid-size-below-min
legsAskSideThinBreakdown	ask-side thinness (no-ask, ask-size-below-min) — disclosed, never a refusal
spreadStats, openInterest, volume24h, minLegSizeAtTouch	whether the quote is real depth or a lonely market maker

Every run also returns one arbitrage_summary row first: how many events were read, how many groups were evaluated, priced and refused, why each refusal happened, and the best group of the run at one contract and at size.

Output example — one row per group

Measured on 2026-08-10 (real run; the four long explanation fields are shortened here with ...)

{
  "type": "basket",
  "eventTicker": "KXGDPYEAR-31",
  "seriesTicker": "KXGDPYEAR",
  "eventTitle": "US real GDP growth in 2031?",
  "subTitle": "2031",
  "category": "Economics",
  "mutuallyExclusive": true,
  "legsTotal": 14,
  "legsPriced": 14,
  "legsUnpriceable": 0,
  "legsUnpriceableBreakdown": {},
  "legsAskSideThin": 0,
  "legsAskSideThinBreakdown": {},
  "minLegSizeAtTouch": 30.0,
  "sumBestBid": 1.0,
  "sumBestAsk": 1.14,
  "sellAllEdgePct": 0.0,
  "sellAllEdgeNetPct": -14.0,
  "sellAllEdgeNetUsd": -0.14,
  "totalFeeUsd": 0.14,
  "sellAllEdgeNetAtScalePct": -6.34,
  "sellAllEdgeNetAtScaleUsd": -0.0634,
  "totalFeeAtScaleUsd": 0.0634,
  "maxCollateralUsd": 0.14,
  "returnOnMaxCollateralPct": -100.0,
  "collateralReturnType": "MECNET",
  "collateralBasis": "mecnet-netted",
  "buyAllEdgePct": null,
  "buyAllEdgeWithheldReason": "Kalshi's mutually_exclusive flag guarantees that AT MOST one leg ...",
  "feeModel": "per order: ceil(0.07 x C x P x (1 - P)) rounded up to the next c ...",
  "feeBasis": "Kalshi rounds the fee up to the next cent once per ORDER, not on ...",
  "capitalBasis": "Edge percentages are per $1 of basket notional, the same convent ...",
  "spreadStats": {
    "min": 0.01,
    "p25": 0.01,
    "median": 0.01,
    "p75": 0.01,
    "max": 0.01,
    "average": 0.01
  },
  "volume24h": 0,
  "openInterest": 8830.26,
  "liquidityUsd": 0,
  "closeTime": "2032-02-29T13:29:00Z",
  "url": "https://kalshi.com/markets/kxgdpyear"
}

The two traps this Actor refuses to fall into

1. "At most one can win" does not mean "one of them must win". Kalshi's mutually_exclusive flag guarantees that at most one leg resolves YES — not that one of them must. Measured 2026-08-10, the event "Who will the next Pope be?" lists 7 cardinals whose asks sum to $0.286. Read naively that is a 71% arbitrage. It is not: the next Pope need not be one of the seven, so buying all seven can pay out $0. Kalshi publishes no flag for "one of these must happen" and nothing in the data implies one.

So sumBestAsk is reported as a plain fact and buyAllEdgePct is always null, with buyAllEdgeWithheldReason saying why. Nothing in the output invites you to trade a number that does not exist. Selling every leg is the side that stays valid when all you know is "at most one can win", and it is the side this Actor prices.

2. Fees are not a rounding error — and they are not a per-contract cent either. Kalshi charges ceil(0.07 x C x P x (1 - P)) rounded up to the next cent once per order, where C is that order's contract count. At C = 1 every leg pays a full cent, so a 14-leg group owes $0.14 against a $1 notional. At size the single ceiling amortises away and the same group owes only sum(0.07 x P x (1 - P)).

Both bounds are published on every priced group, because reporting only one of them is a lie in one direction or the other. Measured 2026-08-10, KXGDPYEAR-31 (US real GDP growth in 2031) has bids summing to exactly $1.0000: flat gross, -14.0% net at one contract, -6.3% at scale. Gross-only numbers would have called that group free; one-contract-only numbers would bury every group whose real edge lives between the two. Both figures are taker fees, because selling every leg hits the resting bid. Kalshi's maker fee is lower on the series that charge one, but that is not this trade at a cheaper rate — a maker sell rests at the ask rather than hitting the bid, so it is a different trade at a different price that may never fill. No maker figure is computed here. The coefficient is the feePctOfNotional input rather than a constant, because a stale fee schedule would quietly overstate every edge forever.

Read returnOnMaxCollateralPct next to minLegSizeAtTouch. Under MECNET the exchange holds only the worst-case loss, so a group that clears $1 ties up little more than the fee — and the return percentage against that tiny base gets very large. It is arithmetically true and it is the point of arbitrage, but the trade is bounded by the size resting at the touch, not by your capital. A large return on $0.14 of collateral is not a large trade, and it is a per-settlement figure, not an annualised rate.

Capital: Kalshi nets it, and says so in the payload

Every event carries collateral_return_type. In the 2026-08-10 run above, all 27 groups the exchange had marked "at most one outcome can win" came back as MECNET — Kalshi's collateral netting for exactly these groups, under which the exchange holds your maximum possible loss on the position, not (1 - price) on each short leg separately.

So when you sell every leg you collect sumBestBid, at most one leg ever pays $1, and maxCollateralUsd = max(0, 1 - sumBestBid) + totalFeeUsd. A three-leg group bidding $1.07 ties up $0.06, not $1.99. The flag is read from that event's own payload and never assumed: anything other than MECNET falls back to the conservative per-leg figure and collateralBasis says which one you got.

What gets refused, and why that is the product

Selling every leg consumes the bid and only the bid, so priceability is judged on the bid side alone:

• an event Kalshi does not mark as "at most one outcome can win" gets mutuallyExclusive: false and no edge figure on either side;
• fewer than minLegs priceable legs is refused outright;
• any unpriceable leg — inactive, no bid, or less size resting on the bid than minSizeAtTouch — voids the edge for the whole group, even when the rest clears minLegs. This guard is conservative, not corrective: dropping a leg lowers sumBestBid, so a subset would read more negative, not more positive. It is refused because selling a subset is a different position with a different payout (the missing leg can resolve YES with nothing paying you for it) — not the group you asked about.

A leg nobody is offering is still perfectly sellable, so no-ask and ask-size-below-min are reported in legsAskSideThinBreakdown as disclosure and never refuse a group. sumBestAsk is still collected wherever every leg is offered.

Every refusal carries a human-readable reason naming the input you would change (minLegs, minSizeAtTouch) and the full breakdown of what was dropped. minEdgePct is applied only after every group has been priced, so the summary counts never shrink just because you set a threshold — and it is keyed off the conservative one-contract figure, with positiveNetEdgeAtScaleBaskets in the summary counting what clears at size.

Price

$0.02 per group priced. Individual legs are $0.002 each and off by default — turn on includeIndividualMarkets if you want them. You pay per group priced; there is no monthly fee. Refused groups are never charged, and neither are groups filtered out by minEdgePct — you pay for the priced groups actually delivered in your results, and nothing else.

Input

This is the input that produced the measured run shown above; feePctOfNotional and includeIndividualMarkets were left at their defaults.

{
  "categories": ["Politics", "Economics", "Elections"],
  "maxEvents": 200,
  "minLegs": 3,
  "minSizeAtTouch": 1,
  "minEdgePct": "-100"
}

Set seriesTickers (e.g. ["KXNEWPOPE"]) to scan specific series instead; it takes precedence over categories.

What the live exchange actually looks like

Measured on 2026-08-10 (real run): 200 open events read, 83 of them in the chosen categories, 66 groups evaluated, 28 events marked "at most one outcome can win", 17 groups priced and 49 refused (39 because Kalshi does not mark them that way, 10 because a leg had no sellable bid). The best gross sell-all edge in the whole set was 0.0% — median -16.0%. That is what a functioning exchange looks like from outside: the bid side of a complete group sums below $1 because of the spread. Use this to find the groups that are closest to crossing, to measure how wide a series is quoted, and to know immediately when one does cross.

Read-only public Kalshi API, no login, throttled requests. Nothing is stored between runs — every call re-reads the live book.

If something goes wrong

• Wrong number or a failed run? Open a ticket on the Issues tab. I read every one and reply within 2 business days (Japan time).
• You never get a fake "empty" result. If the site can't be read, the run fails and says so.
• A group that can't be priced = no charge. A group that does get a price costs $0.02 even when its profit comes out negative — that number is the result you asked for.
• Checked every week. An automatic test runs this tool weekly; if the site changes, I fix it.
• Public pages only. No login, no personal data, and it goes easy on the site.

More tools by the same author

• Polymarket Odds, Volume & Top Markets by Topic
• Polymarket Markets — Odds, Bid/Ask, Volume, One Row Each
• Polymarket Arbitrage Finder — Groups Priced Under $1
• Polymarket vs Kalshi Arbitrage — Same Question, Two Prices

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): https://apify.com/jpmarketdata

Disclaimer

Unofficial, independent tool — not affiliated with, endorsed by, or sponsored by Kalshi. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.