# Kalshi Event Market Data — Contracts API (`nexgensignal/kalshi-event-market-data-api`) Actor

Per-record Kalshi event-contract market data from the public API. Ticker, event, category, yes/no prices, volume, open interest, status, timing. Keyless, informational only, no personal data.

- **URL**: https://apify.com/nexgensignal/kalshi-event-market-data-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 market records

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?

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 Event Market Data — Contracts API

**Keyless. Pay per record. Structured event-contract market data.**

This actor turns **Kalshi's** public event-contract markets into clean, per-market records — the raw market-data layer for the regulated event exchange. Each run reads Kalshi's keyless public API and delivers one row per market: the ticker, the event and category, the yes/no bid-ask prices, the last price, the volume and open interest, the status, and the close/expiration times. Market grain, structured for engineering use, with informational-only disclaimers on every record.

### What this is, in one paragraph

Kalshi runs a regulated exchange of binary event contracts — markets that pay out on real-world outcomes across politics, economics, weather, world events, and more. This actor reads Kalshi's public events API (with nested markets), so each event's category and title travel with every market, and flattens each market into a single analysis-ready record: identity, prices, size, status, and timing. Values are as served by Kalshi's public API. You are billed only for records actually delivered.

### Who buys this and for what job

- **Quant and research teams** ingesting a structured, per-market snapshot of Kalshi event contracts for models and back-tests.
- **Data engineers and app builders** who want the market-data layer as clean rows keyed by ticker and category, without writing a Kalshi client.
- **Dashboards and analytics products** displaying event-contract prices, volume, and open interest by category.
- **Researchers** studying event-market pricing across categories over time.

### Informational data — no advice, not real-time

Three honesty riders travel on every record. This is **informational market data only** — not trading, investment, or financial advice, and not an offer or solicitation to trade. It is **not a real-time feed**: prices, volume, and open interest are as served by Kalshi's public API and may be delayed. And reuse is governed by **Kalshi's own terms**: the data is Kalshi Exchange market data, © Kalshi, provided "as is"; Kalshi's Developer Agreement and terms govern any downstream use — verify on kalshi.com before acting.

### Market grain — no person data

This actor works at market grain: tickers, prices, sizes, and outcomes. There are no natural-person fields in this data, and this actor emits none, with a person-key guard on every record as a backstop.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `market_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `category` | string | — | Optional. Keep only events in this Kalshi category (e.g. Politics, Economics, World, Sports). |
| `statusFilter` | string | — | Optional. Keep only markets with this status (e.g. active, settled). Applied to delivered records. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

### Output

One JSON object per market. Real example (values as served):

```json
{
  "record_id": "KXELONMARS-99",
  "ticker": "KXELONMARS-99",
  "event_ticker": "KXELONMARS-99",
  "series_ticker": "KXELONMARS",
  "market_title": "Will Elon Musk visit Mars before Aug 1, 2099?",
  "event_title": "Will Elon Musk visit Mars in his lifetime?",
  "category": "World",
  "status": "active",
  "market_type": "binary",
  "yes_bid": 0.10,
  "yes_ask": 0.12,
  "no_bid": 0.88,
  "no_ask": 0.90,
  "last_price": 0.10,
  "volume": 117303.13,
  "volume_24h": 59.48,
  "open_interest": 40101.16,
  "open_time": "2025-08-28T20:45:00Z",
  "close_time": "2099-08-01T04:59:00Z",
  "source": "Kalshi (event-contract market data)",
  "source_url": "https://kalshi.com/markets/KXELONMARS",
  "licence": "Kalshi Exchange event-contract market data, © Kalshi ... terms govern any reuse.",
  "attribution": "Data from Kalshi (kalshi.com).",
  "disclaimer": "Informational market data only — NOT trading, investment, or financial advice ... not a real-time feed ...",
  "observed_at": "2026-08-21T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the filters, markets seen and delivered, whether charged equals delivered, and the informational/not-real-time notice.

### Field reference

Each record is one market. Identity: `record_id` / `ticker`, `event_ticker`, `series_ticker`, `market_title`, `event_title`, and `category`. State: `status`, `result` (once settled), and `market_type`. Prices (dollars): `yes_bid`, `yes_ask`, `no_bid`, `no_ask`, `last_price`, and `notional_value`. Size: `volume`, `volume_24h`, `open_interest`, and `liquidity`. Timing: `open_time`, `close_time`, and `expiration_time`. Provenance and caveats: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source's robots posture from your runtime — the API host serves no robots file, a no-policy posture — and stops at the door if that ever changes. It then reads Kalshi's events endpoint with nested markets, page by page via the API's cursor, so each event's category and title are attached to every market it contains. Each market is flattened to one record, prices and sizes parsed to numbers, and delivered **before** it is charged, so a blocked or empty run costs you nothing. Your optional category and status filters are applied per record before delivery, so you are billed only for markets that pass them. The actor paces between pages, stops at your `maxRecords` ceiling, and records `charge_equals_delivered` in the receipt.

### Categories you can pull

Kalshi organizes its markets into events, and each event carries a category — this actor surfaces that category on every market row so a mixed pull stays self-describing and easy to pivot. Categories span the exchange's full breadth: **Politics** and **Elections**, **Economics** (rates, inflation, jobs prints), **World** events, **Climate and Weather**, **Science and Technology**, **Sports**, and more. Because the category comes from the parent event and is attached to each nested market, you can pass a single `category` to build a focused feed — say, only economics markets, or only weather markets — or pull across all of them and group by `category` downstream. Paired with `statusFilter`, you can narrow further to just the active markets (a live snapshot) or just the settled ones (an outcome history), which is the difference between a monitoring feed and a research archive.

### Cost guidance

One `market_record` per delivered market: cost = markets delivered × your plan's per-record price. Kalshi lists thousands of events, each with one or more markets, so scope with `category` and `statusFilter` to keep runs bounded — a single category's active markets is typically a few hundred. 1,000 markets is **$50** (Free) / **$33.50** (Gold).

### Honest limitations

- **Not real-time.** Data is as served by Kalshi's public API and may be delayed; this is a snapshot feed, not a live tick stream.
- **Informational only.** Nothing here is trading, investment, or financial advice, or an offer to trade.
- **Kalshi's terms govern reuse.** The data is Kalshi's; downstream use is subject to Kalshi's Developer Agreement and terms.
- **Market grain.** This is the market-data record — not order books, trade history, or account data.
- **No person data** is emitted.

### Differentiation

The NexGenData fleet already ships **kalshi-prediction-markets-tracker**, which is built around the *odds / implied-probability / volume-tracking* angle for people watching prediction-market movements. This actor is the **market-data / event-contracts API** angle: a clean, per-market structured feed keyed by ticker and category for engineers and analysts who want the data layer rather than a probability tracker. Same source, different job — the two catch different buyer searches, and the sibling is named here so buyers pick the right one.

### The NexGen Signal family

Part of the NexGen Signal family of pay-per-record data products:

- [National Macro Indicator Records — World Bank](https://apify.com/nexgensignal/national-macro-indicator-records)
- [ECB Bank Interest Rate Records — Euro Area MFI](https://apify.com/nexgensignal/ecb-bank-interest-rate-records)
- [US Treasury Fiscal Records — Rates & Debt](https://apify.com/nexgensignal/treasury-fiscal-records)
- [Federal Rulemaking Records — US Federal Register](https://apify.com/nexgensignal/federal-rulemaking-records)
- [Organization Sanctions & LEI Risk](https://apify.com/nexgensignal/organization-sanctions-lei-risk)

*Source: Kalshi public event-contract market API. Kalshi Exchange market data, © Kalshi, provided "as is"; informational use only, not trading advice, not a real-time feed; Kalshi's Developer Agreement and terms govern any reuse. Reformatted to market records; no person data emitted.*

# Actor input Schema

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

Optional. Keep only events in this Kalshi category (e.g. Politics, Economics, World, Sports).

## `statusFilter` (type: `string`):

Optional. Keep only markets with this status (e.g. active, settled). Applied to delivered records.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records delivered.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered Kalshi market records.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/kalshi-event-market-data-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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/kalshi-event-market-data-api").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/kalshi-event-market-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/kalshi-event-market-data-api"
        }
    }
}

```

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/qNpxczg1vJT2mZXxW/builds/Uc765mJJT6o6WzjQ8/openapi.json