🎲 Kalshi Prediction Markets — Odds, Probabilities, Volume

Pay-per-result prediction-market data — $0.10 per market record. Live Kalshi odds, implied probabilities, and volume as clean JSON. No account, no auth handshake, no cents-to-probability math, no Bloomberg seat.

Track live markets on Kalshi, the CFTC-regulated US event-contract exchange, in one structured feed. Every market comes back as a discrete record with its ticker, the full market question, the last traded price, the implied "yes" probability already normalized to 0–1, total trading volume, and the scheduled close time. Filter by status, market title, or event ticker, cap the run size, and drop the result straight into a trading model, an odds dashboard, or a research notebook. Re-run on a schedule and you have a time series of how the crowd priced an event as it unfolded.

Why use this

The raw Kalshi trade API exists, but it is built for order entry, not analytics. It requires an authenticated account, hands you contracts priced in cents (a "62¢ YES" you divide by 100 yourself to get a 62% probability), rate-limits aggressive polling, and offers no convenience layer for filtering or snapshotting the board. This actor collapses all of that into a single call:

• No auth, no account state. Run it with an Apify token like any other actor — no Kalshi API key, no session management.
• Probabilities, not cents. impliedYesProbability arrives pre-normalized to 0–1, so a 62¢ contract is 0.62, ready to compare against your model output or a Polymarket quote without a units conversion step.
• Filter at the source. status, titleContains, and eventContains scope a run precisely, so you pull only the markets you care about and pay only for those rows.
• Pay only for results. $0.10 per market record under Apify's pay-per-event model. A run that matches nothing costs ~one cent. No subscription, no seat license, no idle compute charges.
• Pipeline-ready JSON. Flat records, stable field names, exportable to JSON / JSONL / CSV / Excel — drop into pandas, a warehouse, or a webhook.

What you get

Each emitted record represents one Kalshi market. The six fields:

• ticker — the market's Kalshi ticker (e.g. KXPRES-24-DJT), the stable primary key you dedupe and join on across runs.
• title — the full human-readable market question ("Will the Fed cut rates at the September 2026 meeting?"), exactly as it appears on the exchange.
• lastPrice — the most recent traded price for the YES side, expressed as a probability-equivalent price. A market last trading at 62¢ comes back as 0.62.
• impliedYesProbability — the market-implied probability that the YES side resolves true, normalized to the 0–1 range. This is the number you benchmark a forecast against or chart over time.
• volume — cumulative contracts traded, as an integer. Your liquidity read — thin volume means a quoted probability is fragile.
• closeTime — the scheduled market close, in ISO 8601 (UTC). Tells you how much time is left for the event to resolve and lets you sort markets by horizon.

Use cases

• Event-driven trading research — pull implied probabilities across dozens of contracts in one run and surface mispricings against your own event model or news flow.
• Probability / odds dashboards for media — power a live "the market currently implies X%" widget for election night, economic releases, or sports outcomes without licensing a data terminal.
• Cross-market arbitrage vs Polymarket — pair this with the Polymarket tracker, align on the same event, and flag spreads where Kalshi and Polymarket disagree on the same question.
• Election, sports, and macro event tracking — snapshot every market under an event ticker (presidential race, rate decision, CPI print) and watch the board move toward resolution.
• Model calibration and backtesting — schedule snapshots, store the time series, and score your forecasts against crowd-implied probabilities from a regulated exchange.
• Alerting on probability shifts — diff impliedYesProbability between scheduled runs and fire a Slack / webhook alert when a market jumps past a threshold.
• Liquidity screening — sort by volume to separate deep, tradeable markets from thin ones whose odds carry little information.

Sample output

One record, using only real fields:

{
  "ticker": "KXPRES-24-DJT",
  "title": "Will Donald Trump win the 2024 US presidential election?",
  "lastPrice": 0.62,
  "impliedYesProbability": 0.62,
  "volume": 4821567,
  "closeTime": "2024-11-05T23:59:00Z"
}

A run returns an array of these — one per market matching your filters.

Input parameters

Parameter	Description	Example
status	Market status filter — scope to live markets only.	"open"
titleContains	Keyword match against the market title / question.	"inflation"
eventContains	Filter by event ticker to group all markets under one event.	"KXPRES"
maxResults	Maximum number of markets to return — your hard cost cap.	200

All parameters are optional. Omit everything for the broad live board (bounded by maxResults), or combine eventContains with status: "open" to pull every open contract under one event.

How to use

Python (apify-client):

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "status": "open",
    "titleContains": "inflation",
    "maxResults": 200,
}

run = client.actor("nexgendata/kalshi-prediction-markets-tracker").call(run_input=run_input)

for market in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(market["ticker"], market["impliedYesProbability"], market["volume"])

cURL (run synchronously, get the dataset items back in one call):

curl -X POST \
  "https://api.apify.com/v2/acts/nexgendata~kalshi-prediction-markets-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "status": "open",
    "eventContains": "KXPRES",
    "maxResults": 200
  }'

Results stream into an Apify dataset you can export as JSON, JSONL, CSV, or Excel, or wire to a webhook that fires the moment new rows land.

Pricing

This actor runs on Apify's pay-per-event (PPE) model — you pay for results, not run time:

• Actor start — $0.00005 per run start (one event per GB of run memory, minimum one).
• Market record — $0.10 per market pushed to the dataset.

Worked example: a run that returns 200 markets costs 200 × $0.10 = $20.00 plus the $0.00005 start. A tightly filtered run that returns 12 markets under one event costs 12 × $0.10 = $1.20 plus the start. A run whose filters match nothing costs just the $0.00005 start — you never pay for empty results.

New to Apify? Your account includes $5 in free platform credit to try this actor and 30,000+ others — no credit card required. Browse the full NexGenData catalog at https://apify.com/nexgendata.

How this compares to raw exchange APIs

	Raw Kalshi / exchange API	Kalshi Prediction Markets Tracker (this actor)
Authentication	Account + API key + session handling required	Apify token only — no Kalshi account
Price format	Cents per contract — you normalize yourself	impliedYesProbability pre-normalized to 0–1
Filtering	Roll your own client-side filtering	status, titleContains, eventContains at source
Rate limits	Aggressive polling throttled / blocked	Handled on Apify infrastructure
Dedupe / snapshotting	DIY	Stable ticker key, schedule-friendly rows
Output	JSON you must reshape for analytics	Flat analytics-ready JSON, CSV/Excel export
Cost model	Free API but engineering + maintenance cost	$0.10 per result, zero maintenance

The raw exchange API is the right tool if you are placing orders — it is an order-entry interface first. But if your job is to read the board — pull a slice of markets, normalize the odds, and feed them into a model, a dashboard, or a story — you do not want to babysit an authenticated client, divide cents by 100, and write your own filtering and dedupe layer. This actor gives you normalized implied probabilities as pay-per-result JSON: describe the slice you want, get exactly those rows, priced as probabilities, at $0.10 each.

Schema stability & versioning

This actor follows NexGenData's additive-only schema contract:

• New fields may be added at any time — they appear as new keys in the JSON output and default to null for older runs, so they never break an existing parser.
• Existing fields are never renamed or removed without a major-version bump and an advance changelog notice.
• Field semantics — units, timezones, value ranges (e.g. impliedYesProbability staying in 0–1, closeTime staying ISO 8601 UTC) — are never silently changed. If we must change a meaning, we add a new field and deprecate the old one for at least 90 days.

You can build a production pipeline on these six fields and trust that a Tuesday change won't break a Friday ETL job. Spot something unexpected? Open an issue on the actor's Apify Issues tab and we'll look at it the same day.

Compliance & legal

• The actor reads public market data from a CFTC-regulated exchange, the same way a logged-out browser does. It does not place orders, move funds, or hold positions.
• All requests route through Apify's compliant infrastructure with polite pacing.
• You are responsible for ensuring your downstream use complies with Kalshi's Terms of Service, applicable financial-data rules, and your jurisdiction's prediction-market and event-contract laws — these vary by region and by US state.
• We do not collect, store, or transmit any credentials for the exchange.
• Reading public market data for research, journalism, and analytics is widely accepted; consult counsel before redistribution or before using this data to operate a regulated product.

Run it on a schedule

Kalshi prices move all day, so run it hourly for dashboards and research, or every few minutes when you are watching a live event. Each run is a snapshot of the board at that moment. Between runs, the same markets come back with updated lastPrice, impliedYesProbability and volume, and new markets appear as Kalshi lists them. The actor has no built-in new-only mode; use ticker as the key to stack snapshots into a time series or to compare probabilities between runs. Send each run's results onward with a webhook, Google Sheets, Zapier, Make or the Apify API.

Video guides from Apify: Schedule your Actor · Integrations

FAQ

Why use this instead of the Kalshi API?

The Kalshi API is built for placing orders. It needs an account and API key, and it prices contracts in cents. This actor needs no Kalshi account or key. It returns flat JSON with the implied YES probability already converted to a 0 to 1 number, lets you filter by status, title keyword and event ticker, and runs on a schedule. If you plan to trade, use the exchange's own tools; this actor only reads market data.

What does a typical run cost?

You pay per result, not for run time: $0.10 for each row in the results, plus $0.00005 per run start (charged per GB of run memory, minimum one). A run that returns 25 markets costs about $2.50. Live prices are always shown in the Pricing tab.

How do I get Kalshi odds as JSON or CSV?

Run the actor with status set to open and a maxResults cap. Each market comes back as one record with ticker, title, lastPrice, impliedYesProbability, volume and closeTime. Export the dataset as JSON, JSONL, CSV or Excel.

How do I pull every market for one event, like a Fed rate decision?

Put the event ticker in eventContains (for example KXPRES) and set status to open. To search by topic instead, use titleContains with a keyword such as inflation.

Can I get historical Kalshi prices?

Not directly. Each run returns the current state of the board only. To build history, schedule the actor and keep each run's results, keyed on ticker.

Does it return the full order book or bid and ask depth?

No. Each record has six fields: ticker, title, last price, implied YES probability, volume and close time. It does not return order book depth or individual trades.

Related actors

• Polymarket Scraper — Polymarket Odds, Outcomes & Volume — compare the same event's odds on Polymarket.
• Global Central-Bank Policy Rates (BIS) — rate context for Fed and central bank markets.
• US Treasury Auction Results Tracker API — macro data behind the events Kalshi prices.
• Google News Scraper — Google News API for Headlines — match probability moves to the news that caused them.
• US Treasury Yields & Bond Data — Curve API — track yields alongside rate-decision markets.