# Kalshi Markets Scraper - Odds, Volume, Trades & History (`pipiagent/kalshi-markets-scraper`) Actor

Scrape Kalshi prediction markets: live odds, implied probability, volume, open interest, order books, trades and price history. Search by keyword or category. No API key needed.

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

## Pricing

$1.00 / 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.

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 Markets Scraper

Get live odds, volume, trades and price history from [Kalshi](https://kalshi.com), the largest regulated prediction market in the US. Use it for market research, odds tracking, forecasting models, arbitrage screening against other prediction markets, or to give an AI agent real-time probabilities.

- **Search by keyword or category.** Kalshi's own API has no text search. This Actor does: type `bitcoin`, `fed rate` or `super bowl` and get the matching markets.
- **Clean results, most active first.** Results are sorted by 24h volume by default, and auto-generated parlay markets that flood the raw API are left out.
- **No API key, no login.** Press Start and get data.

### What data can you get?

| Mode | One result is | Main fields |
|---|---|---|
| **Markets** | One market (one outcome) | Implied probability, yes/no bid and ask, last price, volume, 24h volume, open interest, close time, settlement rules, optional order book |
| **Trades** | One executed trade | Time, price, number of contracts, taker side |
| **Price history** | One candle | Open, high, low, close, volume, open interest per 1 minute, 1 hour or 1 day |

### How to use it

1. Click **Try for free**.
2. Leave the input empty to get the 100 most traded open markets, or add keywords and categories.
3. Click **Start**. A full scan of all 100,000+ open markets takes about one minute.
4. Download the results as JSON, CSV or Excel, or read them through the API.

### Input examples

The 50 most active crypto and economics markets:

```json
{
    "categories": ["Crypto", "Economics"],
    "maxItems": 50
}
```

Every market that mentions the Fed, closing within 30 days, with order books:

```json
{
    "searchTerms": ["fed", "interest rate"],
    "closesWithinDays": 30,
    "includeOrderbook": true
}
```

Daily price history for one market over the last 90 days:

```json
{
    "mode": "priceHistory",
    "marketTickers": ["KXSB-27-CHI"],
    "candleInterval": "1440",
    "historyDays": 90
}
```

You can paste kalshi.com market URLs instead of tickers.

### Output example

One result in Markets mode:

```json
{
    "marketTicker": "KXFEDDECISION-26OCT-H0",
    "eventTicker": "KXFEDDECISION-26OCT",
    "seriesTicker": "KXFEDDECISION",
    "title": "Will the Federal Reserve Hike rates by 0bps at their October 2026 meeting?",
    "outcome": "Fed maintains rate",
    "eventTitle": "Fed decision in October 2026?",
    "category": "Economics",
    "status": "active",
    "impliedProbability": 0.295,
    "yesBid": 0.29,
    "yesAsk": 0.30,
    "noBid": 0.70,
    "noAsk": 0.71,
    "spread": 0.01,
    "lastPrice": 0.30,
    "previousPrice": 0.28,
    "priceChange": 0.02,
    "volume": 1367380.71,
    "volume24h": 106349.76,
    "openInterest": 512034.0,
    "closeTime": "2026-10-28T17:59:00Z",
    "rules": "If the Federal Reserve ...",
    "settlementSources": ["Federal Reserve"],
    "url": "https://kalshi.com/markets/kxfeddecision",
    "scrapedAt": "2026-09-29T08:52:47Z"
}
```

Prices are in US dollars per contract, from 0 to 1, so a price of 0.30 means the market gives the outcome about a 30% chance. `impliedProbability` is the midpoint between the best yes bid and ask, or the last traded price when the book is one-sided.

### How much does it cost?

You pay per saved result: **$1.00 per 1,000 results**. There is no start fee and no monthly rental. Filters run before results are saved, so you never pay for markets you filtered out.

| Run | Results | Cost |
|---|---|---|
| Top 100 markets | 100 | $0.10 |
| All open crypto markets | about 1,500 | $1.50 |
| One year of daily candles for 10 markets | 3,650 | $3.65 |

Set a maximum charge per run in the run options and the Actor stops when it is reached.

### Tips

- **Run it on a schedule.** Scrape the same markets every hour to build your own odds history.
- **Use "No sorting" for speed.** With tickers, a series or a narrow category, sorting is not needed and the run finishes in seconds.
- **Events and series.** An event groups related markets, for example one market per team. A series is a recurring event, for example every Fed meeting. Use `eventTickers` or `seriesTickers` to get a whole group at once.

### FAQ

**Is this legal?** The Actor reads only public market data that Kalshi publishes through its official public API. It collects no personal data.

**Can it place trades?** No. It is read-only.

**Why is the order book showing only bids?** Kalshi books hold bids only. A yes ask at price X is the same order as a no bid at 1 - X.

**Something is broken or missing?** Open a ticket in the Issues tab. Issues are usually answered within a day.

# Actor input Schema

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

Markets: current odds, volume and open interest. Trades: every executed trade. Price history: OHLC candles for the markets you list.

## `searchTerms` (type: `array`):

Keep only markets whose title, outcome or ticker contains one of these keywords, for example "bitcoin", "fed rate" or "super bowl". Leave empty to get all markets.

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

Keep only markets in these Kalshi categories. Leave empty for all categories.

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

Open markets are tradable now. Closed markets have stopped trading. Settled markets have a final result.

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

Which markets come first when there are more matches than "Max results". "No sorting" is the fastest because it stops as soon as enough markets are found.

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

Maximum number of results to save.

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

Specific market tickers or kalshi.com market URLs. Required for price history. In trades mode, leave empty to get trades across all markets.

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

Get every market that belongs to these events, for example "KXFED-26DEC".

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

Get every market in these recurring series, for example "KXBTC" or "KXFED".

## `minVolume24h` (type: `integer`):

Skip markets that traded fewer contracts than this in the last 24 hours.

## `minOpenInterest` (type: `integer`):

Skip markets with fewer open contracts than this.

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

Keep only markets that close within this many days.

## `includeOrderbook` (type: `boolean`):

Add bid levels with price and size to every market. Makes one extra request per market, so runs take longer.

## `orderbookDepth` (type: `integer`):

Number of price levels per side.

## `includeRules` (type: `boolean`):

Add the rule text and settlement sources that decide how each market resolves.

## `tradesSinceHours` (type: `integer`):

Trades mode only. How far back to collect trades.

## `candleInterval` (type: `string`):

Price history mode only. Length of each candle.

## `historyDays` (type: `integer`):

Price history mode only. How many days back to go.

## Actor input object example

```json
{
  "mode": "markets",
  "searchTerms": [
    "bitcoin",
    "fed rate"
  ],
  "status": "open",
  "sortBy": "volume24h",
  "maxItems": 100,
  "includeOrderbook": false,
  "orderbookDepth": 10,
  "includeRules": true,
  "tradesSinceHours": 24,
  "candleInterval": "1440",
  "historyDays": 30
}
```

# Actor output Schema

## `results` (type: `string`):

Markets, trades or price candles saved by the run, one item per result.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pipiagent/kalshi-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pipiagent/kalshi-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 '{}' |
apify call pipiagent/kalshi-markets-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pipiagent/kalshi-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/qRRaUB1Ud4jPHyuhq/builds/vDJPMAPoqIRtO6R6g/openapi.json