🎲 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 signal — 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.01, charged once per run.
• Market record — $0.10 per market pushed to the dataset.

Worked example: a run that returns 200 markets costs $0.01 + 200 × $0.10 = $20.01. A tightly filtered run that returns 12 markets under one event costs $0.01 + 12 × $0.10 = $1.21. A run whose filters match nothing costs just the $0.01 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?fpr=2ayu9b.

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.

FAQ

Q: How fresh is the data? A: Each run pulls live from Kalshi at execution time — the prices, probabilities, and volumes reflect the market at the moment the run fires. For trading-style monitoring, schedule the actor on a tight interval (every few minutes) and dedupe on ticker to build a time series.

Q: What exactly is impliedYesProbability? A: It is the market-implied probability that the YES side of a contract resolves true, normalized to 0–1. Kalshi prices contracts in cents (a YES at 62¢ pays $1 if it resolves true), so the cent price is itself a probability estimate — we hand it to you as 0.62 so you can compare it directly against a model output or another venue's quote.

Q: Can I filter by event? A: Yes — eventContains matches against the event ticker, so you can pull every market under a single event (an election, a rate decision, a tournament) in one run. Combine it with status: "open" to restrict to live contracts.

Q: Do you provide historical data? A: The actor returns the current state of the board on each run. To build history, schedule it and persist the snapshots — ticker + closeTime give you stable keys to assemble a time series in your own warehouse.

Q: What output formats are supported? A: JSON, JSONL, CSV, and Excel via Apify dataset export, plus webhooks for streaming new rows into a downstream pipeline.

Q: Is this legal? A: The actor reads public market data the same way a logged-out browser would. Kalshi is a CFTC-regulated exchange and the market data is public. You are responsible for your downstream use and for complying with prediction-market and event-contract laws in your own jurisdiction — see Compliance & legal below.

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.

Related NexGenData actors

Part of the NexGenData Finance & Markets suite — compose these to build a full markets-data backend without a terminal seat:

• Polymarket Prediction Markets Tracker — the same odds + volume feed for Polymarket; pair with this actor for cross-venue arbitrage on identical events.
• US Treasury Auction Results — bid-to-cover, high yield, and award data behind the macro events Kalshi prices.
• Global Central Bank Policy Rates — the live policy-rate context for every "will the Fed cut?" market.
• Crypto Top-100 Screener — market cap, price, and volume across the top 100 coins.
• DeFi TVL Protocol Tracker — total-value-locked across DeFi protocols.
• Finviz Stock Screener — US equities filtered by sector, fundamentals, and technicals.

Explore the full catalog of 200+ pay-per-result finance and markets actors at https://apify.com/nexgendata?fpr=2ayu9b.