BTCBTC$64,334-0.04%|
ETHETH$1,809.87+0.59%|
USDTUSDT$0.99933-0.01%|
BNBBNB$589.5100-0.00%|
USDCUSDC$0.99962-0.00%|
XRPXRP$0.95388+0.86%|
SOLSOL$72.3300+2.08%|
TRXTRX$0.30585+1.19%|
FIGR_HELOCFIGR_HELOC$1.0390+0.00%|
HYPEHYPE$68.7000+2.77%|
ZECZEC$914.7600+3.05%|
XMRXMR$509.5700+3.72%|
DOGEDOGE$0.05850+0.19%|
LEOLEO$9.2900+0.98%|
USDSUSDS$0.99992+0.01%|
WBTWBT$62.1500-0.16%|
LINKLINK$9.1200+0.31%|
ADAADA$0.15227+0.19%|
USDEUSDE$0.99937-0.01%|
XLMXLM$0.13704-0.13%|
DAIDAI$0.99981-0.03%|
BCHBCH$209.0400+1.71%|
NEARNEAR$3.2000+0.61%|
RAINRAIN$0.00557753-28.99%|
LTCLTC$44.4000+0.06%|
CCCC$0.08063-3.20%|
UNIUNI$5.2700+2.75%|
AVAXAVAX$7.1300+0.01%|
XAUTXAUT$3,845.44+0.09%|
SUISUI$0.72027+0.20%|
BTCBTC$64,334-0.04%|
ETHETH$1,809.87+0.59%|
USDTUSDT$0.99933-0.01%|
BNBBNB$589.5100-0.00%|
USDCUSDC$0.99962-0.00%|
XRPXRP$0.95388+0.86%|
SOLSOL$72.3300+2.08%|
TRXTRX$0.30585+1.19%|
FIGR_HELOCFIGR_HELOC$1.0390+0.00%|
HYPEHYPE$68.7000+2.77%|
ZECZEC$914.7600+3.05%|
XMRXMR$509.5700+3.72%|
DOGEDOGE$0.05850+0.19%|
LEOLEO$9.2900+0.98%|
USDSUSDS$0.99992+0.01%|
WBTWBT$62.1500-0.16%|
LINKLINK$9.1200+0.31%|
ADAADA$0.15227+0.19%|
USDEUSDE$0.99937-0.01%|
XLMXLM$0.13704-0.13%|
DAIDAI$0.99981-0.03%|
BCHBCH$209.0400+1.71%|
NEARNEAR$3.2000+0.61%|
RAINRAIN$0.00557753-28.99%|
LTCLTC$44.4000+0.06%|
CCCC$0.08063-3.20%|
UNIUNI$5.2700+2.75%|
AVAXAVAX$7.1300+0.01%|
XAUTXAUT$3,845.44+0.09%|
SUISUI$0.72027+0.20%|
Kalshi API
Tool / APITier-2Official APIVerified

Kalshi API

The exchange's own API — public market data with no key, signed endpoints for orders and streaming, and the only route to Kalshi's non-sports markets such as elections, economics and weather.

Visit website

Key Facts

CategoryOfficial API
AccessPublic market-data endpoints need no key at all; authenticated endpoints need a Kalshi account and an asymmetric API key pair (Ed25519 preferred, RSA-PSS supported for older clients), created in account settings or through the API itself. What varies is throughput rather than a subscription: token budgets run from Basic at 200 read / 100 write tokens per second up to Prestige at 12,000 / 9,600, with Advanced available by calling an upgrade endpoint and the higher tiers earned automatically from trailing 30-day trading volume as 30-day grants. Batch endpoints cost the same as individual calls, and the developer documentation publishes no API subscription price. A demo environment with mock funds and separate credentials is available for testing.
Venues CoveredKalshi — the exchange's own event-contract markets, plus a separate API surface for its perpetual futures (margin), which is documented alongside the predictions API.
Data ConfidenceVerified
Last Reviewed1 Oct 2026

What It Does

Kalshi's official exchange API: the venue's own interface to its event-contract markets over REST, WebSocket and FIX, with a separate surface for its perpetual futures. Public endpoints answer without any credentials — series, events, markets and order books — while portfolio, order and streaming endpoints use asymmetric API key pairs (Ed25519 preferred, RSA-PSS supported) carried in three signed headers. Because it returns whole order books rather than a single price, depth and implied spreads are visible; it splits live data from an advancing historical archive with per-datatype cutoffs; and it exposes the full market lifecycle from creation through determination to settlement. Throughput is metered in tokens against read and write budgets that run from Basic to Prestige, the higher tiers earned from 30-day trading volume, and the developer documentation publishes no API subscription price. A demo environment with separate credentials and mock funds mirrors production, and official Python and TypeScript SDKs sit alongside the OpenAPI and AsyncAPI specifications the vendor treats as the source of truth.

Overview

What it is

Kalshi's Trade API is the exchange's own interface to its event-contract markets — REST, WebSocket and FIX, with a separate surface for the exchange's perpetual futures. The developer documentation that this page's visit link points to now serves from docs.kalshi.com. Production REST calls go to https://external-api.kalshi.com/trade-api/v2 and streaming to wss://external-api-ws.kalshi.com/trade-api/ws/v2, with a demo environment on its own hosts and its own credentials.

Two things separate it from most entries in this directory. It is the venue itself rather than a vendor reselling venue data, and large parts of it are open: series, events, markets and order books all answer without an API key.

Why a prediction-market reader cares

Every other data source in this directory describes Kalshi from the outside, and most of them only where Kalshi overlaps with something else. Odds APIs carry Kalshi as a bookmaker slug for sports markets where their coverage lines up — NFL and NBA in the case of OddsPapi, per its own developer guide — and aggregators index the markets that carry volume. Kalshi's own API is the only place that answers for the whole exchange: elections, economic indicators, weather, technology, entertainment, and the combination markets built out of them.

It is also the primary source for the things a secondary source cannot reconstruct: the full order book with the size behind each level, the settlement result and its timestamp, the market lifecycle events, and the trading surface itself. Where an odds or analytics API gives you a price, this gives you the book that produced it and the exchange's own record of how the market resolved.

Public endpoints, no key required

The documentation's market-data quick start walks through three unauthenticated calls: fetch a series, list its markets filtered by series_ticker and status=open, then pull the order book for one ticker. No authentication headers are needed for any of them, which makes the API usable for research before you have ever signed up — and makes it the cheapest way to check whether a market you care about exists and how thin it is.

Signing in, not logging in

API keys are asymmetric key pairs rather than shared secrets: you sign each request with a private key and the exchange verifies it against the registered public key. Ed25519 is the recommended type; RSA-PSS with SHA-256 remains supported for clients limited to it, including SDK versions before 3.31.0. Each request carries KALSHI-ACCESS-KEY, KALSHI-ACCESS-TIMESTAMP and KALSHI-ACCESS-SIGNATURE, where the signature is the base64 encoding of the signed concatenation of the timestamp, the HTTP method and the path — with the query string stripped. The private key is shown once at creation and cannot be retrieved afterwards, and demo credentials do not work against production.

The order book returns bids only

The order book endpoint returns yes_dollars and no_dollars bid arrays and no asks, which looks like a gap until you work through the arithmetic of a binary market: a YES bid at price X is identical to a NO ask at $1.00 − X. Every ask is therefore implied by the opposite side's best bid, and the endpoint avoids publishing the same information twice. It has a practical consequence for reading the data: the two arrays are sorted ascending, so the best bid is the last element of each array, and the spread you can actually trade is the implied ask minus the best bid — not the distance between the two highest bids.

Prices and contracts are fixed-point strings

Prices arrive as _dollars strings with up to four decimal places and contract quantities as _fp strings with up to two, so sub-cent pricing and fractional contract sizes are representable — and integer-cent fields cannot express a sub-cent price, which is why the dollar strings are the ones to read. Each market's valid prices are a grid, published as price_ranges (start, end, step bands) and labelled by price_level_structure; that grid is the source of truth and off-grid prices are rejected. Whole-cent prices are valid in every structure, and the newer tapered grids put a finer tick below $0.10 and above $0.90, where a one-cent move swings implied probability by far more than it does mid-range. Combination markets get the finest grid of all, at $0.0001. Sub-cent prices and fractional sizes can also produce balance changes finer than an account's precision, which is why the exchange applies a rounding fee with a per-order accumulator and rebates rather than simply truncating.

Throughput is the constraint, not the invoice

What the documentation rations is requests, not dollars: each call costs tokens, your tier sets the rate at which your budget refills, and your sustained request rate is budget divided by cost. Most requests cost the default of 10 tokens, and GET /account/endpoint_costs is the authoritative list of the exceptions. Read and write have independent budgets — GET traffic draws on read, while order placement, amends, cancels, order groups, the RFQ quote flow and block-trade accepts draw on write — and the split is by operation rather than protocol, so REST and FIX drain the same buckets. Tiers run from Basic at 200 read / 100 write tokens per second to Prestige at 12,000 / 9,600.

Where it sits in this directory

Three layers are worth keeping apart. OddsPapi puts Kalshi beside 350+ sportsbooks so that a Kalshi price can be judged against a sharp reference rather than in isolation. Dune dashboards and the index and analytics providers supply historical and aggregate views across venues. Polymarket's own CLOB and Gamma APIs are the sibling official venue API for the other large prediction market. Kalshi's API sits underneath all of that as the primary record for one venue: deepest on the markets nobody else carries, and the only route to execution — but single-venue by definition, so it can never tell you whether a Kalshi price is good relative to anywhere else.

Numbers that move under you

Three figures in these docs are explicitly dynamic and should be read at runtime rather than hard-coded. Endpoint token costs change, with the default of 10 the only fixed one. Tier entitlements are grants: volume-earned tiers are reviewed daily, last 30 days, and have separate earn and keep thresholds, so a quiet month can lapse a tier. And the historical cutoffs advance over time and differ for each data type, so a window that works today will silently exclude data later. The documentation also warns that its own endpoint-cost list is the current one in effect, which is the clearest possible signal that the others are not permanent.

How It Works

Finding the first market

The documented path is series, then markets, then order book — GET /series/{ticker}, GET /markets?series_ticker=...&status=open, then GET /markets/{ticker}/orderbook. Markets can be filtered by a single status (unopened, open, paused, closed, settled), by event ticker, by series ticker, by a comma-separated list of tickers, or by created, updated, close and settled timestamps — but only one status filter per call, and the timestamp filters are mutually exclusive with each other and with some status filters, so most collectors issue several calls rather than one clever query. Combination markets are separated by mve_filter=only or exclude. Pages default to 100 items and accept up to 1,000, and every list endpoint is cursor-paginated: pass the returned cursor back as cursor until it comes back null.

What a market response actually carries

A market object is identified by its ticker and its event_ticker, and carries its titles and outcome sub-titles alongside the numbers you came for: yes_bid_dollars and yes_ask_dollars, traded volume_fp, the price_ranges grid, the trading and expiry timestamps, and the exchange's own status. The time fields are worth reading carefully — expected_expiration_time is when the outcome is likely to be known and can sit before close_time, because a market may stay open well past the event to allow for rescheduling. That single distinction is the difference between a data pipeline that quietly reports stale prices as live and one that knows the market is still trading toward an outcome already known.

  • Statuses run initialized, active, inactive (a pause), closed, determined, disputed, amended, finalized.
  • Transitions are either implicit (time passing) or announced — activated, deactivated, close_date_updated, determined, settled — so a poller that misses events sees changes it cannot explain.
  • After close every order operation is rejected with MARKET_INACTIVE, resting orders are cancelled shortly after close, and reactivating a paused market cancels resting orders on that market.

Signing a request correctly

Signing is the step that breaks most first integrations, and its rules are narrow. Build the pre-sign string as the millisecond timestamp, the HTTP method and the request path, in that order, concatenated with no separators; sign it with the private key; base64 the result. Ed25519 signs the message itself, while RSA keys use RSA-PSS over SHA-256 with a salt equal to the digest length. The path is signed without query parameters — a request to /portfolio/orders?limit=5 signs only /portfolio/orders — and the hostname is never part of the payload, which is why the same signature works against production and demo hosts. Keys can be generated in account settings, registered through POST /trade-api/v2/api_keys with your own PEM, or issued by POST /trade-api/v2/api_keys/generate with a key_type.

Reading depth instead of just a price

The best YES bid is the last entry in yes_dollars and the implied YES ask is $1.00 minus the last entry in no_dollars. Summing quantities backwards from the best bid within a band — five cents is a reasonable band — gives you the size available near the touch, which is the number that decides whether a quoted price is tradeable in your size. Two details make this more than an arithmetic exercise: quantities are fractional strings, and a wide implied spread on a low-volume market is a normal state rather than a data error. A price is only a price if there is size behind it, and this endpoint is one of the few in this directory that lets you check that yourself.

Streaming with the WebSocket API

Polling /markets on a timer works, but the WebSocket API is where a data product should live. The session is authenticated during the handshake with the same three headers, signing timestamp + GET + /trade-api/ws/v2; after that, channels divide into private ones — orderbook_delta, fill, market_positions, communications, order_group_updates — and market-data channels that carry no additional per-channel authorisation: ticker, trade, market_lifecycle_v2, multivariate_market_lifecycle and multivariate. Order books arrive as a snapshot followed by deltas, and the optional client_order_id on a delta tells you whether your own order caused the change. Errors come back as typed codes rather than HTTP statuses — 8 for an unknown channel, 9 for missing authentication, 10 for an internal channel error — and the documented lifecycle is subscribe, receive, and reconnect with exponential backoff when the socket drops.

Live versus historical, and the cutoff between them

Kalshi partitions exchange data into live and historical tiers so the live endpoints stay fast, and the boundary is published rather than fixed: GET /historical/cutoff returns a set of timestamps — market_settled_ts for markets and their candlesticks, trades_created_ts for trades and fills, orders_updated_ts for completed orders, market_positions_last_updated_ts for positions — and each one advances over time. Records older than their cutoff disappear from the live endpoints and appear only under /historical/.... Events and series never move, so historical context is available from the original endpoints even when the markets beneath them have been archived.

The positions handoff deserves special care: it happens as a buffered, whole-event move, so a settled position can still be live after its own last-update timestamp, and the documented procedure is to query both the live and historical position endpoints, page the live one first, then deduplicate by subaccount and ticker — the vendor states plainly that the two reads are not one snapshot. Settlement records are the one gap: /portfolio/settlements reads only settled positions still in the live set, and there is no historical endpoint carrying the same fields.

If you need to trade, not just read

The same API that serves market data also executes. The documented create-order call takes the market ticker, a side of bid, a fractional count as a string, a price in the fixed-point format ("0.0100"), a time_in_force, a self-trade prevention mode and an optional client_order_id. That last field is the one to adopt early: it makes retries idempotent, so a response lost to a dropped connection cannot become a second order, and a duplicate submission is rejected with a 409 instead of filling twice. Amend and cancel are separate endpoints on the same order path, prices are validated to the 1–99 cent range, and execution fees are modelled separately from the price rather than baked into it. For larger flows the API also exposes order groups, which cancel automatically against rolling contract limits, subaccounts that isolate balances within one account, and an RFQ system with a quote flow.

Rate limits in practice

Budgets are token buckets that refill continuously, with no fixed windows to time your calls against. Above the Basic tier a write bucket holds three seconds of budget, as do the Basic and Advanced read buckets, so a client that sits idle between market moves can spend up to three times its per-second budget in one burst before throttling back to the refill rate; the faster read tiers and the Basic write bucket hold only one second and bank nothing.

TierRead (tokens/sec)Write (tokens/sec)
Basic200100
Advanced300300
Expert600600
Premier1,2001,200
Paragon2,4002,400
Prime4,8004,800
Prestige12,0009,600

Two behaviours catch people out. Batching saves round trips but not tokens — a 25-order create batch costs 25 times the per-order cost and must fit in the bucket at once or the whole batch is rejected. And a rate-limited request returns 429 with no Retry-After or X-RateLimit-* headers, so backoff is entirely the client's problem; there is no penalty or cooldown beyond the refill itself.

Maintenance windows and pauses

Kalshi runs scheduled maintenance every Thursday from 3:00 to 5:00 AM ET with a trading pause in effect, and expects clients to reconnect once it ends. Two pause types behave differently, which matters if you hold resting orders: during a trading pause you cannot place or amend but you can still cancel, while during a rarer exchange pause cancels are rejected as well. Resting orders stay on the book through either unless the order was created with cancel_order_on_pause, in which case the exchange cancels it for you. GET /exchange/status reports whether the exchange and trading are active, whether internal transfers are permitted, and an estimated resume time — a sensible health check before any strategy assumes the book is open.

SDKs, specifications and FIX

Official SDKs exist for Python (synchronous and asynchronous packages) and TypeScript, and the older kalshi-python package is deprecated in favour of the two Python packages. The vendor is explicit that the SDKs are updated periodically and may lag the API, and recommends treating the OpenAPI specification for REST and the AsyncAPI specification for WebSocket as the source of truth — generating your own client, or integrating directly, for full control. Ed25519 keys require SDK 3.31.0 or later; RSA keys work with every version. A FIX interface is documented alongside REST and WebSocket for order entry and market settlement messages, with its own specification files, and the perpetual futures surface is specified separately from the event-contract API.

Method Notes & Limitations

Where this page's facts come from

Everything here was read from Kalshi's own developer documentation on 1 October 2026: the quick starts for market data, authenticated requests, order creation and WebSockets, plus the pages covering API keys, environments, pagination, order book responses, fixed-point representation, historical data, rate limits and tiers, market lifecycle, settlement, maintenance and pauses, and the SDK overview. The trading-api.readme.io address this page links to serves that same documentation, which is why the sources below cite the canonical documentation host. No Kalshi account was created, no API key was generated, no request was made against the API, and no latency, uptime or fill-quality measurement was taken.

Verified against the documentation

ClaimStatus
Series, events, markets and order books are readable without authenticationVerified — the market-data quick start states it and uses no auth headers
Three signed headers, with the signature covering timestamp + method + path and query parameters strippedVerified — API keys and environments pages
Asymmetric key pairs, Ed25519 recommended, RSA-PSS for clients limited to itVerified — API keys page
Demo environment with separate credentials and its own hostsVerified — demo and environments pages
Token budgets split across read and write buckets, with the published tier tableVerified — rate limits page
Batch requests cost the same as individual calls and must fit the bucket at onceVerified — rate limits page
429 responses carry no Retry-After or X-RateLimit headersVerified — rate limits page, stated as a current limitation
Live and historical tiers with per-datatype cutoffs and a buffered positions handoffVerified — historical data page
Thursday 03:00–05:00 ET maintenance, and the difference between a trading and an exchange pauseVerified — maintenance and pauses page
Latency, uptime, throughput and fill qualityNot tested, and not claimed anywhere on this page

What this page does not claim

No latency, throughput, uptime or fill-quality figure appears here, because none was measured and the documentation makes no such promises. Nor does this page call the API cheap or expensive in dollars: the developer documentation publishes no API subscription price at all, so cost is described in tokens and tiers, which is what the documentation actually specifies. If API pricing matters to your build, that is a question for Kalshi rather than something this page can answer from public material.

Limits worth planning around

Four constraints shape real builds. The Thursday maintenance window is a weekly certainty and clients should reconnect rather than assume continuity. A 429 gives no retry hint, so exponential backoff is mandatory rather than optional. The live/historical split means a backtest or reconciliation that queries only the live endpoints will silently lose older data as cutoffs advance, and the positions handoff is explicitly not a single snapshot — the documented approach is to read both endpoints and deduplicate. And because endpoint token costs and tier entitlements both move, budgets should be read at runtime from the account endpoints rather than hard-coded into a client.

Editorial note

Bitnxt is not affiliated with Kalshi, has no commercial relationship with it and receives nothing from it; this page carries no referral arrangement and no trading links. Kalshi is unusual in this directory in that the venue and the API provider are the same company, which cuts both ways: it has no reason to overstate another venue's coverage, and equally no reason to publish anything unflattering about its own rate limits or maintenance windows. The documentation is candid about both, which is why they are described here in detail. Nothing on this page is investment advice, and a market data feed is not a trading strategy.

Venues Covered

Kalshi — the exchange's own event-contract markets, plus a separate API surface for its perpetual futures (margin), which is documented alongside the predictions API.

Access & Pricing

Public market-data endpoints need no key at all; authenticated endpoints need a Kalshi account and an asymmetric API key pair (Ed25519 preferred, RSA-PSS supported for older clients), created in account settings or through the API itself. What varies is throughput rather than a subscription: token budgets run from Basic at 200 read / 100 write tokens per second up to Prestige at 12,000 / 9,600, with Advanced available by calling an upgrade endpoint and the higher tiers earned automatically from trailing 30-day trading volume as 30-day grants. Batch endpoints cost the same as individual calls, and the developer documentation publishes no API subscription price. A demo environment with mock funds and separate credentials is available for testing.

Frequently Asked Questions

Sources & Verification

The factual claims on this page were checked against the sources below.

Bitnxt uses cookies to run the site, understand how it is used, and measure ads. You can accept or decline below, and change your choice any time in our Privacy Policy.