# Kalshi Prediction Markets Scraper (`parselab/kalshi-prediction-markets-scraper`) Actor

Scrape Kalshi prediction markets with live odds, bid and ask, spread, volume, open interest, rules and results. Also get event summaries, order books, trades, price history candles and a Kalshi vs Polymarket price comparison. Filter by category, keyword or ticker. Export to CSV or Excel.

- **URL**: https://apify.com/parselab/kalshi-prediction-markets-scraper.md
- **Developed by:** [ParseLab](https://apify.com/parselab) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kalshi Prediction Markets Scraper

This Kalshi scraper collects prediction markets from Kalshi, the US regulated exchange where people trade on the outcome of elections, the Federal Reserve, inflation, sports, crypto prices, weather and more. Each market comes back as a clean row with the live yes and no bid and ask, the spread, the last trade, the implied probability, volume, open interest, the closing time, the exact rules and, for finished markets, the result.

It goes further than a market list. You can also get an events summary, the full order book with depth, the trade tape, price history candles for any market, and a comparison that matches similar questions on Kalshi and Polymarket and shows the price gap between the two.

Traders, analysts, journalists, researchers and developers use it to follow the odds, build dashboards and study how markets move.

### What can you do with this Kalshi scraper?

- Get live Kalshi odds for all economics, politics or sports markets
- Find markets that close in the next few days
- See the most traded markets by total or 24 hour volume
- Read the exact rules that decide how a market settles
- Pull settled markets with their results to study how well prices predicted outcomes
- Get the full order book with depth within 5 cents of the best price
- Download trades for a market with price, size and taker side
- Build hourly or daily price charts from candles
- Compare Kalshi prices with Polymarket prices for the same question
- Export Kalshi data to CSV or Excel

### What data can you extract from Kalshi?

| Mode | One row is | Highlights |
|---|---|---|
| Markets and odds | One market | Ticker, event, series, category, outcome, yes and no bid and ask, sizes, spread, midpoint, last price, implied probability and its source, volume, 24 hour volume, open interest, open and close time, hours to close, result, settlement value, rules, share of the event |
| Events summary | One event | Market count, total volume, open interest, leading outcome and price, first and last close, settlement sources, market tickers |
| Order book depth | One market | Best bid and ask for yes and no, spread, price levels, total depth, depth within 5 cents, full book |
| Trades | One trade | Time, yes and no price, contracts, taker side, block trade flag |
| Price history | One candle | Open, high, low, close, mean, bid and ask at close, volume, open interest |
| Kalshi vs Polymarket | One matched pair | Both questions, both prices, price gap, which side is cheaper, similarity score and match quality |

Prices are in dollars for a contract that pays 1 dollar, so 0.28 means the market implies a 28 percent chance.

### How to scrape Kalshi

1. Choose **What to collect**, for example Markets and odds.
2. Pick the status: open, closed, settled or all.
3. Add categories, keywords or tickers to narrow the search.
4. Set **Max Items** and click **Start**.
5. Export the dataset as CSV, Excel or from the Apify console.

For order book, trades and price history, paste the market tickers from a markets run into **Market tickers**.

### Input example

```json
{
  "mode": "markets",
  "status": "open",
  "categories": ["Sports"],
  "closesWithinDays": 3,
  "onlyPriced": true,
  "sortBy": "volume",
  "maxItems": 100
}
```

### Market output example

```json
{
  "ticker": "KXNFLGAME-26SEP21NYGLAR-NYG",
  "eventTitle": "NY Giants vs LA Rams",
  "category": "Sports",
  "outcome": "New York G",
  "status": "active",
  "yesBid": 0.27,
  "yesAsk": 0.28,
  "lastPrice": 0.28,
  "spread": 0.01,
  "impliedProbabilityPct": 27.5,
  "impliedProbabilitySource": "midpoint",
  "volume": 2632149.83,
  "volume24h": 1269744.76,
  "openInterest": 2268458.45,
  "closeTime": "2026-09-24T00:15:00Z",
  "hoursToClose": 67.7,
  "shareOfEventPct": 27.45
}
```

### Price history output example

```json
{
  "ticker": "KXNFLGAME-26SEP21NYGLAR-NYG",
  "periodMinutes": 60,
  "periodEnd": "2026-09-11T05:00:00.000Z",
  "open": 0.2,
  "high": 0.2,
  "low": 0.19,
  "close": 0.2,
  "yesBidClose": 0.19,
  "yesAskClose": 0.2,
  "volume": 73.67,
  "openInterest": 14234.13
}
```

### How much does it cost to scrape Kalshi?

You pay per result: $17 per 1,000 rows plus a tiny start fee. The free plan returns up to 10 rows per run. An order book is one row per market, and one day of hourly candles is 24 rows.

### Tips for better results

- The implied probability uses the midpoint of the bid and ask when the spread is 10 cents or less. When the book is wide it uses the last trade, and the source is shown in the row.
- Filtering by category or series is much faster than scanning everything. Sorting reads all matching markets first.
- Combo markets are excluded by default. There are thousands of them and most have no trading. Turn them on only if you need them.
- In events where only one outcome can win, the share of event column normalizes the last prices so they add up to 100 percent.
- The Kalshi vs Polymarket comparison uses similar titles, so read the match quality and the rules of both markets before you act on a gap.

### Who uses prediction market data?

- **Traders** compare odds across markets and platforms.
- **Journalists** quote market-implied probabilities in stories.
- **Researchers** test how accurate market prices are.
- **Developers** feed dashboards, bots and alerts.

### Automate and connect

Schedule the Actor every hour with the same filters and keep each run to build your own price history. Send finished datasets to Google Sheets, Zapier, Make or n8n, or trigger a webhook when a run ends.

### FAQ

**Do I need a Kalshi account?**
No. The Actor works without any login and reads public market data only.

**Does it place trades?**
No. It only reads data.

**Why is the order book empty for some markets?**
Markets with no quotes have no depth. Try markets with volume.

**How accurate is the Kalshi vs Polymarket match?**
It is an automatic match on titles. Strong matches are usually the same question, weak matches often are not. Always compare the rules.

**Can I get weather markets?**
Yes. Use the category Climate and Weather or a series ticker such as KXHIGHNY.

### Legal note

This Actor collects information that is publicly visible on the website. Check the source site's terms and your local rules before using the data. It is not affiliated with Kalshi or Polymarket. Nothing here is financial or betting advice.

### Support

Missing a field or found a bug? Open an issue from the Actor page.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `mode` (type: `string`):

Markets gives one row per market with odds, order book top, volume and rules. Events gives one summary row per event. Order book gives the full depth of chosen markets. Trades gives recent trades. Price history gives candles over time. Kalshi vs Polymarket matches similar questions on both platforms and shows the price gap.

## `status` (type: `string`):

Open markets can be traded now. Closed markets stopped trading and wait for the result. Settled markets have a result.

## `categories` (type: `array`):

Kalshi categories, for example Politics, Elections, Economics, Sports, Financials, Crypto, Climate and Weather, Entertainment, Science and Technology, Health, Companies, World.

## `keywords` (type: `array`):

Keep markets whose title, outcome or rules contain any of these words, for example Fed, bitcoin, Trump.

## `seriesTickers` (type: `array`):

Series codes such as KXFEDDECISION or KXHIGHNY. A series groups the recurring events of one topic.

## `eventTickers` (type: `array`):

Event codes such as KXNFLGAME-26SEP21NYGLAR.

## `marketTickers` (type: `array`):

Market codes. Required for order book, trades and price history modes, for example KXNFLGAME-26SEP21NYGLAR-NYG. You can copy them from a markets run.

## `minVolume` (type: `number`):

Only markets with at least this many contracts traded in total.

## `minOpenInterest` (type: `number`):

Only markets with at least this many contracts held open.

## `onlyPriced` (type: `boolean`):

Skip markets that have no quote and no trade yet.

## `closesWithinDays` (type: `integer`):

Only markets that close within this many days from now.

## `sortBy` (type: `string`):

Sorting reads all matching markets first, so the run takes longer. None keeps the order of the source.

## `includeCombos` (type: `boolean`):

Include the multi-leg parlay style markets. They are excluded by default because there are thousands of them and most have no trading.

## `candlePeriod` (type: `string`):

Size of each price candle in price history mode.

## `daysBack` (type: `integer`):

How far back to read price history and trades. The default is 1 day for 1 minute candles, 14 days for hourly and 90 days for daily.

## `minSimilarity` (type: `number`):

For the Kalshi vs Polymarket comparison: how similar two titles must be to count as a match, from 0.3 to 1. Higher is stricter.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "markets",
  "status": "open",
  "categories": [
    "Economics"
  ],
  "onlyPriced": false,
  "sortBy": "none",
  "includeCombos": false,
  "candlePeriod": "1hour",
  "minSimilarity": 0.6
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "categories": [
        "Economics"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parselab/kalshi-prediction-markets-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "categories": ["Economics"],
}

# Run the Actor and wait for it to finish
run = client.actor("parselab/kalshi-prediction-markets-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "categories": [
    "Economics"
  ]
}' |
apify call parselab/kalshi-prediction-markets-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parselab/kalshi-prediction-markets-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/iBzxwkxoKOdPSV3KI/builds/tsRQhR0KuTIYVCdwT/openapi.json