# Kalshi Markets & Odds API (`fkdg_digital/kalshi-markets-odds-api`) Actor

Clean, normalized Kalshi prediction-market data: markets, live two-sided quotes, volumes and liquidity. No API key needed, parlays filtered out.

- **URL**: https://apify.com/fkdg\_digital/kalshi-markets-odds-api.md
- **Developed by:** [Franclim Diogo](https://apify.com/fkdg_digital) (community)
- **Categories:** Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / fetch run

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Kalshi Markets & Odds API — live prediction market data

Get clean, normalized **Kalshi prediction-market data** — every open market with live quotes, implied probabilities, volumes, liquidity and open interest — as a ready-to-use dataset. **No API key, no auth, no setup.**

Kalshi's raw API is powerful but full of traps: prices arrive as strings, the `/markets` endpoint is flooded with hundreds of thousands of multivariate parlay combos without quotes, and half the fields need decoding. This Actor is the plumbing done right, so you can build on top of the data instead of fighting it.

### What you get

Each row is one market, flat and typed:

| Field | Description |
|---|---|
| `ticker`, `event_ticker` | Kalshi identifiers |
| `title`, `subtitle`, `category` | Event title + market sub-title (e.g. candidate, threshold) |
| `yes_ask`, `yes_bid`, `no_ask`, `no_bid`, `last_price` | Live prices as floats (dollars, 0–1) |
| `implied_prob_pct` | Implied probability of YES (yes\_ask × 100) |
| `spread` | yes\_ask − yes\_bid |
| `quoted` | True when the market has live two-sided quotes |
| `volume_24h`, `liquidity`, `open_interest` | Activity metrics |
| `close_time`, `url` | When it closes + direct Kalshi link |

### Why this Actor

- **Parlays filtered out** — multivariate combo markets (no standalone quotes) are excluded, leaving only real, tradeable markets.
- **Quotes guaranteed two-sided** — by default every row has a live yes ask *and* no ask strictly between 0 and 1.
- **Clean flat schema** — prices parsed to floats, volumes to integers; no string-decoding on your side.
- **MCP-ready** — output schema included, so AI agents can consume this Actor programmatically.

### Modes

- **All quoted markets** (default) — the full live snapshot, sorted by 24h volume.
- **Search** — case-insensitive match on title + subtitle (`searchQuery: "bitcoin"`, `"fed decision"`, `"premier league"`).
- **Closing soon** — only markets closing within `closingWithinHours` (default 24) — useful for expiry plays and monitoring.

Filters: `minVolume24h`, `minLiquidity`, `maxResults`, `maxPages` (each page ≈ 200 events).

### Use cases

- **Dashboards** — live odds boards for politics, sports, economics, weather
- **Bots & alerts** — feed a trading or notification pipeline on a schedule
- **Research** — snapshot market-implied probabilities over time
- **Arbitrage tooling** — pair it with my [Polymarket × Kalshi Arbitrage Scanner](https://apify.com/fkdg_digital/polymarket-kalshi-arbitrage-scanner) to hunt cross-platform mispricings

### Honest notes

- This is **public market data**; prices move fast — schedule frequent runs if freshness matters.
- Kalshi's public events endpoint currently reports `liquidity` as 0 for all markets — judge executability by `volume_24h`, `open_interest` and `spread` instead. The field stays in the schema in case Kalshi starts populating it.
- Prices are order-book asks/bids at fetch time, not guaranteed fills.
- Not financial advice.

### Pricing

Pay-per-event: a small flat fee per fetch run plus a tiny per-row fee. You only pay for the data you get.

# Actor input Schema

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

What to fetch: all quoted markets, a search over titles, or markets closing soon.

## `searchQuery` (type: `string`):

Case-insensitive match on event title + market subtitle (used in 'search' mode). Matches a substring or all words.

## `closingWithinHours` (type: `integer`):

In 'closing\_soon' mode, only markets closing within this many hours.

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

Skip markets with 24h volume below this value.

## `minLiquidity` (type: `integer`):

Skip markets with liquidity below this value. NOTE: Kalshi's public events endpoint currently reports 0 liquidity for all markets — leave at 0 and use minVolume24h instead.

## `quotedOnly` (type: `boolean`):

Keep only markets with live two-sided quotes (0 < yes\_ask < 1 and 0 < no\_ask < 1). Recommended.

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

Cap on output rows (sorted by 24h volume).

## `maxPages` (type: `integer`):

How many pages of 200 events to fetch (more pages = more markets, slower run).

## Actor input object example

```json
{
  "mode": "all_quoted",
  "closingWithinHours": 24,
  "minVolume24h": 0,
  "minLiquidity": 0,
  "quotedOnly": true,
  "maxResults": 500,
  "maxPages": 15
}
```

# Actor output Schema

## `markets` (type: `string`):

Normalized Kalshi markets with live quotes, sorted by 24h volume.

## `report` (type: `string`):

Events scanned, markets total, quoted count, parameters and errors.

# 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("fkdg_digital/kalshi-markets-odds-api").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("fkdg_digital/kalshi-markets-odds-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 fkdg_digital/kalshi-markets-odds-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fkdg_digital/kalshi-markets-odds-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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