datagrit › Guides › Kalshi Settlement Calendar & Order Book Depth

How to list Kalshi markets that settle in the next 24 hours with Python

Build a Kalshi settlement calendar with bid, ask, spread, volume and order book depth near the touch, filtered by liquidity, using Python or cURL.

Published 2026-10-01 · uses the Kalshi Settlement Calendar & Order Book Depth Actor

On a prediction market, time to settlement shapes how you trade. A contract that resolves tonight is a different position from one that resolves in March, and close to settlement the data feed that decides the outcome matters more than any opinion.

If you trade on Kalshi, build bots for it or study its markets, the question you keep asking is: which open markets settle in the next N hours, which of them are actually quoted, and how much can I trade near the best price? Kalshi's public API holds all the pieces. It just does not give them to you as one table.

This post shows what the API offers, the traps in combining it, and how to get a settlement calendar with liquidity attached in one call.

Where the data comes from

Kalshi exposes a public market data API at api.elections.kalshi.com/trade-api/v2 that needs no account for reading. It has markets (with quotes, volume, open interest and timing fields), a series catalog (with categories, frequency and settlement sources) and order books per market.

Building a settlement calendar on top of it involves more than one endpoint and several surprises:

• The right time field. Markets have a close time, a latest settlement time and an expected settlement time (expected_expiration_time). Many markets can close early, so the close time is often far later than when the market actually resolves. The Kalshi Settlement Calendar Actor on Apify filters and sorts on the expected settlement time.
• Scale. The exchange had 126,003 open markets when the Actor's memory use was last measured. Scanning them all and keeping a sorted window without exhausting memory needs care; the Actor keeps only the best maxItems candidates while it scans.
• Series matching. Settlement sources live on the series, not the market. Series tickers can contain dashes (KXBTCD-B versus KXBTCD), so splitting an event ticker at the first dash attaches the wrong series. The Actor matches the longest event ticker prefix present in the catalog.
• Category membership. A series can be listed under several categories. 1,041 of 14,527 series were, so filtering on the single category field silently drops markets. The Actor uses the full membership list.
• Combination markets. Multivariate "combo" markets can flood results if the exclusion filter is not applied. The Actor checks every row against the series catalog and the market fields, skips combination markets, and fails the run before billing if they make up more than 1% of the scan.
• Order book depth. The raw book lists every level. What a trader usually needs is how many contracts sit within a few cents of the best bid and ask.

Step by step

1. Define the input

Crypto and financial markets settling within the next 24 hours, with at least some activity and a spread of 3 cents or less:

{
  "settlesWithinHours": 24,
  "settlesAfterHours": 0,
  "categories": ["Crypto", "Financials"],
  "seriesTickers": [],
  "keywords": [],
  "minVolume24h": 100,
  "minOpenInterest": 0,
  "requireTwoSidedQuote": true,
  "maxSpreadCents": 3,
  "sortBy": "settlement",
  "includeOrderbook": true,
  "depthCents": 5,
  "includeRules": false,
  "maxItems": 50
}

sortBy accepts settlement, volume24h, openInterest or spread. A negative settlesAfterHours (for example -6) also lists markets whose expected settlement time has passed but which have not settled yet. Naming seriesTickers such as KXBTCD is much faster than scanning the whole exchange: a run without named series scans the full catalog, which takes about a minute and a half.

2. Run it from Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "settlesWithinHours": 24,
    "seriesTickers": ["KXBTCD"],
    "maxSpreadCents": 3,
    "includeOrderbook": True,
    "depthCents": 5,
    "maxItems": 50,
}

run = client.actor("datagrit/kalshi-settlement-calendar").call(run_input=run_input)
markets = [m for m in client.dataset(run["defaultDatasetId"]).iterate_items() if m.get("found")]

for m in markets:
    print(f'{m["hoursToSettle"]:>6}h  {m["ticker"]:<32} bid {m["yesBid"]} ask {m["yesAsk"]} '
          f'depth {m["yesBidDepth"]}/{m["yesAskDepth"]}')

3. Or with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/datagrit~kalshi-settlement-calendar/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"settlesWithinHours": 48, "seriesTickers": ["KXBTCD"], "maxItems": 20}'

What you get

One row per open market. Prices are in dollars (0.58 = 58 cents, read as a 58% implied probability); volume, open interest and depth are in contracts.

Rows also carry seriesTicker, seriesTitle, category, categories, frequency, outcome, closeTime, latestSettlementTime, canCloseEarly, settlementSourceUrls, midPrice, NO-side quotes, sizes at the touch, whole-book levels and totals, and, if requested, the rules text.

Recipes

Hourly "settling next" sheet

Schedule the Actor hourly with settlesWithinHours: 6 and sortBy: "settlement", and write the dataset to Google Sheets through an Apify integration or a short script. The sheet always shows what resolves next, with the spread and depth needed to judge whether it is tradable.

Liquidity screen before sizing an order

import pandas as pd

df = pd.DataFrame(markets)
tradable = df[(df["spreadCents"] <= 2) & (df["yesAskDepth"] >= 500)]
print(tradable.sort_values("hoursToSettle")[["ticker", "hoursToSettle", "midPrice", "spreadCents", "yesAskDepth"]])

yesAskDepth counts contracts you can buy within the depth window above the best ask, so it is a direct answer to "can I get 500 contracts without walking the book more than 5 cents?".

Grouping by settlement source

Run with a one-week window (settlesWithinHours: 168), then group by settlementSources. That shows which data feeds (for example CF Benchmarks for the Bitcoin series) decide the most markets this week, which helps when you build source-specific models or alerts.

Limitations

• Expected settlement time is a schedule, not a guarantee. Some markets close early once the outcome is known; a few settle later.
• Only single-outcome, active markets. Combination markets and markets with another status are excluded.
• Full-exchange scans take time. About a minute and a half without named series; name series or categories to shorten it.
• Depth can be missing for a market if its order book could not be read or depth is off. If no order book can be read at all, the run fails instead of returning empty depth.
• The run fails on source changes. If Kalshi stops publishing a field a filter or sort depends on (expected settlement time, 24h volume, open interest, settlement sources), the run stops and bills nothing, rather than returning rows that look valid.
• Read-only: the Actor uses the public market data API, does not log in and does not place orders.

Wrapping up

A settlement-sorted view with depth near the touch is a small thing that saves a lot of glue code; pricing is pay per result, the Actor is on Apify, and every field is described in the documentation.

More guides