
Kalshi Open Interest and Order Book Data Explained
If your code throws KeyError: 'open_interest' on a Kalshi market, it is older than March 12, 2026. On that date Kalshi removed the integer-cent and integer-count fields from the entire REST and WebSocket surface, and market data now arrives as fixed-point dollar strings (yes_bid_dollars) and fixed-point contract counts (open_interest_fp). The same migration reshaped the order book, which returns bids only, wrapped in orderbook_fp.
Every number below was checked against production on October 26, 2026 at 08:23 UTC on KXFEDDECISION-26OCT-H0, the Fed-holds-rates market for the October 2026 meeting.
Key Takeaway: Open interest (
open_interest_fp) is a contract count per market, not a dollar value. The order book (orderbook_fp) contains bids for YES and NO only, sorted ascending with the best bid last, so the best YES ask is one dollar minus the best NO bid. Depth within a few cents of the top tells you whether your size fits; the top of book does not.
What open interest actually measures
Open interest is the number of contracts in a market that are open and unsettled. It measures how much exposure is held, not how much traded, and the two move independently:
open_interest_fp: 3,157,236.80 contractsvolume_fp(all time): 7,660,294.46 contractsvolume_24h_fp: 298,832.27 contracts
A market can trade all day without open interest moving when both sides pass the same contracts back and forth. It can also build open interest while volume stays flat, which is what happened here: daily candles show open interest climbing from 2,025,347.01 on October 21 to 3,078,388.26 on October 26 while the YES bid rose from 0.87 to 0.93. Rising open interest into a rising price is new money agreeing with the existing consensus. Falling open interest into a rising price usually means the move came from traders closing positions on thin volume.
Open interest is strictly a per-market number. The same event, KXFEDDECISION-26OCT, has five outcome markets, and the one most likely to resolve held only a part of the total: 3,157,130.88 on the hold, 2,308,557.18 on a 25bp hike, 1,421,131.42 on a 25bp cut, 932,341.88 and 234,228.94 on the two tails. Summed, the event carried 8,053,390.30 contracts. If you quote “the open interest of the Fed market” you are summing five fields yourself; the API does not return it.
The field names changed, and old code breaks quietly
The Fixed-Point Representation page is the reference. Two rules cover nearly everything: prices are dollar strings with a _dollars suffix and up to 4 decimals ("0.9300"), contract quantities are strings with an _fp suffix and up to 2 decimals ("140637.90", minimum 0.01 contracts).
open_interestbecomesopen_interest_fp,volumebecomesvolume_fpyes_bid/yes_askbecomeyes_bid_dollars/yes_ask_dollars, same forno_orderbookbecomesorderbook_fp- Trade
countbecomescount_fp,yes_pricebecomesyes_price_dollars
A live market object returned 41 fields on October 26, 2026 and not one legacy name was among them. The failure mode is unpleasant: code reading market["yes_bid"] does not print a wrong number, it raises, and a bare except returning zero will show a dead market instead of an error.
Two fields are worth reading while you are there: yes_bid_size_fp and yes_ask_size_fp give contracts resting at the top, and price_ranges gives the valid tick grid for that market. Tick sizes differ, KXFEDDECISION-26OCT-H0 uses linear_cent with a one-cent step while combo markets use center_deci_edge_centi_cent with sub-cent steps, so never hardcode a cent.
Why the Kalshi order book has no asks
GET /markets/{ticker}/orderbook returns bids for both sides, because a YES bid at X is the same order as a NO ask at 1 minus X. The Orderbook Responses guide states it directly, and after the migration the response looks like this:
{
"orderbook_fp": {
"yes_dollars": [["0.0100", "229636.37"], ["0.9200", "86213.58"], ["0.9300", "140637.90"]],
"no_dollars": [["0.0400", "303617.86"], ["0.0500", "935689.70"], ["0.0600", "747359.06"]]
}
}
Each entry is [price_dollars, count_fp], arrays are sorted ascending, and the best bid is the last element. From that book at 08:23 UTC:
- Best YES bid
0.9300with 140,637.90 contracts, best NO bid0.0600with 747,359.06 - Best YES ask is 1 minus 0.06 = 0.9400, implied by the NO bids
- Spread: 1.00 cent
That derivation matches yes_ask_dollars on the market object exactly, which is the cleanest check on your own parsing.
Depth, not top of book, decides whether your size fits
The top of book said 747,359 contracts were offered at 0.94. That is the visible part. Walking the YES bids shows what your own order does:
- Selling 1,000 YES: filled entirely at 0.9300
- Selling 100,000 YES: filled entirely at 0.9300
- Selling 800,000 YES: filled, but at an average of 0.3986
- Selling 900,000 YES: only 808,960 filled, 91,040 left unmatched
The whole YES bid side held 808,963 contracts across 59 price levels, so the top level was 17 percent of it. Measured as contracts within two cents of the best bid, depth was 232,501.48 on the YES side and 1,988,646.37 on the NO side. The NO bid side is the YES ask side, so buying YES in size is easy and selling YES in size is not. That asymmetry is invisible in the headline price.
Python: open interest plus book depth in one script
No API key needed; public market data endpoints are unauthenticated. Only portfolio and trading calls need the signed headers from the API key guide.
import json, urllib.request
from decimal import Decimal
BASE = "https://api.elections.kalshi.com/trade-api/v2"
TICKER = "KXFEDDECISION-26OCT-H0"
def get(path):
with urllib.request.urlopen(f"{BASE}{path}", timeout=20) as r:
return json.load(r)
def depth_within(levels, cents):
"""levels: [[price_dollars, count_fp], ...] ascending. Best bid last."""
if not levels:
return Decimal("0")
limit = Decimal(levels[-1][0]) - Decimal(cents) / Decimal("100")
return sum((Decimal(c) for p, c in reversed(levels) if Decimal(p) >= limit), Decimal("0"))
market = get(f"/markets/{TICKER}")["market"]
book = get(f"/markets/{TICKER}/orderbook")["orderbook_fp"]
yes, no = book["yes_dollars"], book["no_dollars"]
best_bid = Decimal(yes[-1][0]) if yes else None
best_ask = Decimal("1") - Decimal(no[-1][0]) if no else None
print(f"open interest {market['open_interest_fp']}")
print(f"volume 24h {market['volume_24h_fp']}")
print(f"bid / ask {best_bid} / {best_ask} spread {(best_ask - best_bid) * 100} cents")
print(f"depth within 2c YES {depth_within(yes, 2)} NO {depth_within(no, 2)}")
Real output from that snapshot:
open interest 3157236.80
volume 24h 298832.27
bid / ask 0.9300 / 0.9400 spread 1.0000 cents
depth within 2c YES 232501.48 NO 1988646.37
Sizes move between calls; treat contract counts as a snapshot and the derivation rules as the stable part. If you are polling in a loop, the WebSocket guide covers ticker and orderbook_delta plus the measured latency that decides whether you can react at all.
Practical notes from building on this data
- Batch the books.
GET /markets/orderbooks?tickers=A&tickers=Btakes the parameter repeated, up to 100 tickers. A comma-joined string returns one entry with an empty book instead of an error. - Filter out the combos.
GET /marketsorders by creation time, so the first pages are fresh multivariate markets with zero interest. Addmve_filter=excludeandstatus=open, then rank byopen_interest_fp. - Page size.
limit=1000works,limit=2000returns HTTP 400. There were more than 3,000 open markets on October 26, 2026, so a full scan means three or more pages with the returnedcursor. - Candles carry open interest. The candlestick endpoint returns
open_interest_fp,volume_fpandyes_bid/yes_askOHLC in dollars atperiod_interval1, 60 or 1440 minutes. Itspriceblock stays empty until the market prints a trade, so use the bid and ask closes for early history.
What the spread and the fee do to a one-cent market
At 0.93 bid against 0.94 ask, crossing costs one cent, or 1.06 percent of a 0.94 stake. The taker fee model adds 0.07 × P × (1 - P), which at P = 0.94 is 0.003948 dollars per contract, or 0.39 cents. That is roughly 1.5 percent of your risk before the position has done anything, and per-fill balance rounding can push a single small fill higher until the fee accumulator rebates it. Run the numbers on the payout calculator before sizing, and never assume zero fees.
Expert insight: The most common data mistake on Kalshi is not a parsing bug. It is quoting a per-market open interest as if it described an event, or quoting top-of-book size as if it were available depth. Both numbers are true and both mislead on their own.
If you would rather read these fields than rebuild them weekly, the Kalshi market data page tracks open interest, volume and spreads across the markets we follow, and the free cheat sheet puts the field names on one page. For a live example of why bid size and not price decides your exit, our 2026 midterm odds page reads the Senate control book five days before Election Day. Live prices straight from the exchange, and the source of every number above, are on Kalshi. Heading towards backtests next? The historical data guide picks up where this leaves off.
EdgeOutcome may earn a commission if you sign up through links on this page. It does not change what we publish or which numbers we report.
18+. Prediction markets involve real financial risk. Availability depends on your country and US state.
Frequently Asked Questions
What is open interest on Kalshi?
Open interest is the number of contracts in a market that are still open and not yet settled. It is reported per market, not per event, in the field open_interest_fp. On October 26, 2026 the KXFEDDECISION-26OCT-H0 market showed 3,157,236.80 contracts of open interest while the five outcome markets of the same event summed to 8,053,390.30 contracts.
Why does my code fail with open_interest or yes_bid on the Kalshi API?
Because Kalshi removed the legacy integer count fields and integer-cent price fields from all REST and WebSocket responses on March 12, 2026. Use open_interest_fp instead of open_interest, volume_fp instead of volume, yes_bid_dollars instead of yes_bid, and orderbook_fp instead of orderbook. We confirmed it on October 26, 2026: a live market object returned 41 fields and none of the legacy names were among them.
Why does the Kalshi order book only return bids?
In a binary market a YES bid at price X is the same order as a NO ask at 1 minus X, so one side describes both. The endpoint returns orderbook_fp with yes_dollars and no_dollars, each an array of [price_dollars, count_fp] string pairs in ascending price order. The best YES bid is the last element of yes_dollars, the best YES ask is 1 minus the last element of no_dollars.
How do I find the most liquid Kalshi markets?
There is no sort parameter on GET /markets, and the default order is newest first, dominated by multivariate combo markets. Filter with mve_filter=exclude and status=open, page with the cursor at limit=1000 (limit=2000 returns HTTP 400), and rank by open_interest_fp or volume_24h_fp yourself. Querying one series at a time with series_ticker is faster for a single cluster.
Does open interest mean the money in a Kalshi market?
No, it is a contract count, not a dollar amount. Multiply by a price to get exposure: 3,157,236.80 contracts at the 0.93 YES bid on October 26, 2026 is about 2.9 million dollars at that price. Volume is a separate field and counts contracts traded, not contracts held.