# Kalshi Markets Scraper (`talcoe/kalshi-markets`) Actor

Kalshi prediction market prices, volume, open interest and expiration, filterable by category, status and keyword, priced per result.

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

## Pricing

from $5.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

### What does Kalshi Markets Scraper do?

Kalshi Markets Scraper returns live Kalshi prediction market data: yes and no bid and ask prices, last traded price, volume, open interest, liquidity, and open, close and expiration dates. Filter by category, market status or a keyword to pull only the markets you care about, whether that is election odds, Fed rate calls, or weather and sports contracts. Pricing is per result, so a filtered run only charges for the rows you actually get.

### Data source

Data comes straight from Kalshi's public trade API (`api.elections.kalshi.com/trade-api/v2/events`), the same JSON feed the Kalshi site itself calls, so prices and volume are as fresh as the exchange.

### Why use it?

- Track prediction market odds for elections, economic data releases, or news events as a leading indicator.
- Feed a spreadsheet or dashboard with live contract prices and volume without hand copying from the site.
- Screen markets by category or keyword to build a watchlist, for example every Fed rate or weather market.
- Replace manually checking the Kalshi site for price moves with a scheduled run that lands in a database or Sheet.

### How to use it

1. Open the Actor and set the category, status or keyword filters, or leave them blank for the most active open markets.
2. Click Start. Download results as JSON, CSV or Excel, or read them through the API.
3. Add a Schedule and an Integration (Slack, Google Sheets, webhook) to get price updates automatically.

### Input

| Field | Description |
|---|---|
| `category` | Only return markets in this category (Politics, Sports, Crypto, and so on). Leave blank for all categories. |
| `status` | Market status: open (trading now), closed (awaiting settlement), settled (final result) or unopened (scheduled). Defaults to open. |
| `keyword` | Only return markets whose title or subtitle contains this text. Leave blank for no filter. |
| `seriesTicker` | Only return markets in one series, for example `KXELONMARS`. Leave blank for all series. |
| `maxResults` | Hard stop for the run. You are billed per result, so this caps the cost. |
| `proxyConfiguration` | Apify proxy is recommended for larger runs. |

Example input:

```json
{
    "category": "Politics",
    "status": "open",
    "keyword": "",
    "seriesTicker": "",
    "maxResults": 60
}
```

### Output

Every record has the same shape:

```json
{
    "id": "KXELONMARS-99",
    "ticker": "KXELONMARS-99",
    "title": "Will Elon Musk visit Mars before Aug 1, 2099?",
    "category": "World",
    "status": "active",
    "yesBid": 0.1,
    "yesAsk": 0.12,
    "volume": 118844.56,
    "closeTime": "2099-08-01T04:59:00Z",
    "subtitle": "Mars",
    "noBid": 0.88,
    "noAsk": 0.9,
    "lastPrice": 0.1,
    "volume24h": 0,
    "openInterest": 40063.58,
    "liquidity": 0,
    "openTime": "2025-08-28T20:45:00Z",
    "expirationTime": "2099-08-08T15:00:00Z",
    "eventTicker": "KXELONMARS-99",
    "seriesTicker": "KXELONMARS",
    "rulesPrimary": "If Elon Musk visits Mars before the earlier of his death or Aug 1, 2099, then the market resolves to Yes.",
    "url": "https://kalshi.com/markets/kxelonmars",
    "scrapedAt": "2026-09-19T01:24:37.124Z"
}
```

| Field | Meaning |
|---|---|
| `id` | Stable key (the market ticker), safe for deduplication between runs |
| `ticker` | Kalshi market ticker |
| `title` | Market question |
| `category` | Kalshi category, for example Politics or Sports |
| `status` | Market status: active, closed or settled |
| `yesBid` / `yesAsk` | Best yes bid and ask, in dollars (0 to 1, read as a probability) |
| `volume` | Total contracts traded since the market opened |
| `closeTime` | When the market stops trading, ISO format |
| `subtitle` | Short label for this specific contract within the event |
| `noBid` / `noAsk` | Best no bid and ask, in dollars |
| `lastPrice` | Last traded price, in dollars |
| `volume24h` | Contracts traded in the last 24 hours |
| `openInterest` | Open contracts outstanding |
| `liquidity` | Dollar value resting on the order book |
| `openTime` | When the market started trading, ISO format |
| `expirationTime` | When the market expires and settles, ISO format |
| `eventTicker` | Ticker of the parent event this market belongs to |
| `seriesTicker` | Ticker of the series this event belongs to |
| `rulesPrimary` | Plain language resolution rule for the market |
| `url` | Link to the market's series page on kalshi.com |

### Pricing

Pay per event: a small fee when a run starts, then a fixed price per result returned. You only pay for records that pass your filters. Set `maxResults` to cap any run.

### Limitations

- Read only: order book depth beyond best bid and ask, and any account or trading data, are not included since those require a login.
- Category and status use the values Kalshi assigns to each market, so a market Kalshi has not tagged with a category will not match a category filter.
- Keyword matching is a plain text search over the market title and subtitle, not a full text search across market rules.

### FAQ

**Is this legal?** The Actor reads market data Kalshi's public API publishes for any visitor without a login and stores only that market data. You are responsible for how you use the data.

**Something is missing or broken?** Open an issue in the Issues tab; response time is usually under a day.

# Actor input Schema

## `category` (type: `string`):

Only return markets in this category. Leave blank for all categories.

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

Open markets are still trading. Closed markets stopped trading and are awaiting settlement. Settled markets have a final result.

## `keyword` (type: `string`):

Only return markets whose title or subtitle contains this text. Leave blank for no filter.

## `seriesTicker` (type: `string`):

Only return markets in this series, for example KXELONMARS. Leave blank for all series.

## `maxResults` (type: `integer`):

Hard stop for the run. You are billed per result, so this caps the cost.

## `proxyConfiguration` (type: `object`):

Apify proxy is recommended for larger runs.

## Actor input object example

```json
{
  "category": "",
  "status": "open",
  "keyword": "",
  "seriesTicker": "",
  "maxResults": 60,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "category": "",
    "status": "open",
    "keyword": "",
    "seriesTicker": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("talcoe/kalshi-markets").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 = {
    "category": "",
    "status": "open",
    "keyword": "",
    "seriesTicker": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("talcoe/kalshi-markets").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 '{
  "category": "",
  "status": "open",
  "keyword": "",
  "seriesTicker": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call talcoe/kalshi-markets --silent --output-dataset

```

## MCP server setup

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

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/m3MBXeY3DKnNBt0jo/builds/txpX5M7IJA8g7hrsP/openapi.json