# Kalshi Markets Scraper (`automation-lab/kalshi-markets-scraper`) Actor

Export Kalshi prediction markets, odds, bids, asks, liquidity, volume, open interest, dates, outcomes, and rules. No login required; schedule runs or use the API.

- **URL**: https://apify.com/automation-lab/kalshi-markets-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper exports public prediction-market contracts from Kalshi into clean JSON, CSV, Excel, XML, or API-ready datasets.

It uses Kalshi's structured public market-data API, so **no Kalshi login, API key, browser, or proxy is required**.

Use it for live odds snapshots, liquidity screens, recurring forecasting research, historical settlement exports, and data pipelines.

### What does Kalshi Markets Scraper do?

The Actor retrieves one normalized record per Kalshi market contract.

Each record can include:

- 📈 YES and NO bid/ask prices
- 💧 liquidity, volume, 24-hour volume, and open interest
- 🗓️ open, close, and expiration timestamps
- 🎯 market, event, and series tickers
- 📜 market rules, result, and expiration value
- 🧩 multivariate-event legs and custom strike data
- 🔗 stable source API and Kalshi market links

You can browse the catalog or request exact contract tickers.

Cursor pagination supports both small samples and larger exports.

### Who is Kalshi Markets Scraper for?

**Prediction-market analysts**

- Compare implied probabilities across active contracts.
- Build recurring snapshots of price and liquidity changes.
- Export settled outcomes for forecast evaluation.

**Quant and data teams**

- Feed normalized market records into warehouses or notebooks.
- Screen for minimum liquidity, volume, or open interest.
- Join Kalshi contracts with other market datasets using tickers.

**Journalists and researchers**

- Track market sentiment around elections, economics, weather, and events.
- Cite source-backed contract titles, rules, and timestamps.
- Schedule reproducible data collections for longitudinal analysis.

**Trading dashboards and automation builders**

- Refresh market catalogs on an Apify schedule.
- Trigger webhooks when a downstream rule detects a change.
- Connect datasets to Sheets, Make, Zapier, Slack, or a database.

### Why use this Kalshi scraper?

- ✅ **No credentials:** reads anonymous public market data.
- ✅ **Structured API:** avoids brittle browser selectors.
- ✅ **Contract-level rows:** every dataset item is one market.
- ✅ **Useful filters:** status, event, series, dates, keyword, liquidity, volume, and open interest.
- ✅ **Exact lookup:** retrieve known market tickers directly.
- ✅ **Normalized numbers:** dollar and fixed-point strings become JSON numbers.
- ✅ **Raw preservation:** `rawJson` retains the complete source market object.
- ✅ **Resilient requests:** retries 429 and temporary server failures with backoff.
- ✅ **Apify platform:** schedule runs, call an API, export files, and connect integrations.

### What Kalshi market data can you extract?

| Category | Fields |
|---|---|
| Identity | `ticker`, `eventTicker`, `seriesTicker`, `title` |
| Outcomes | `yesSubtitle`, `noSubtitle`, `result`, `expirationValue` |
| Quotes | `yesBid`, `yesAsk`, `noBid`, `noAsk`, `lastPrice`, previous quotes |
| Order sizes | `yesBidSize`, `yesAskSize` |
| Activity | `liquidity`, `volume`, `volume24h`, `openInterest` |
| Lifecycle | `status`, `openTime`, `closeTime`, expiration and update dates |
| Mechanics | market type, strike type, price ranges, provisional and early-close flags |
| Rules | primary and secondary rules, settlement sources |
| Multivariate | collection ticker, selected market legs and sides |
| Provenance | Kalshi URL, source API URL, scrape timestamp, raw source JSON |

Optional event enrichment adds category, series ticker, event title, event subtitle, exclusivity, and settlement sources.

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

This Actor uses **pay-per-event pricing**.

You pay a small run-start fee plus a fee for each market saved successfully.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Market saved | $0.000030926 | $0.000026892 | $0.000020976 | $0.000016135 | $0.000010757 | $0.00001 |

**Cost examples:**

Calculated at the Free tier as the run-start charge + saved markets × the Free per-market rate.

| Saved markets | Estimated charge |
|---:|---:|
| 10 | ~$0.00531 |
| 100 | ~$0.00809 |
| 1,000 | ~$0.03593 |

Your Apify Free plan includes monthly platform credits, so small evaluations can fit within those credits.

Prices are formula-derived from a representative current-build cloud run and include the fixed run-start fee.

### How to scrape Kalshi prediction markets

1. Open [Kalshi Markets Scraper](https://apify.com/automation-lab/kalshi-markets-scraper).
2. Keep **Market status** set to `open` for a live snapshot.
3. Optionally enter a series ticker, event ticker, exact market tickers, or numeric thresholds.
4. Set **Maximum markets** to the number of contracts you need.
5. Click **Start**.
6. Open the Dataset tab to inspect the result.
7. Export JSON, CSV, Excel, XML, or RSS, or retrieve the dataset through the API.

A simple live snapshot:

```json
{
  "status": "open",
  "maxItems": 25,
  "pageSize": 100,
  "maxPages": 5
}
````

One recurring series with event context:

```json
{
  "seriesTicker": "KXHIGHNY",
  "status": "open",
  "includeEventDetails": true,
  "maxItems": 100
}
```

A liquidity scan:

```json
{
  "status": "open",
  "minLiquidityDollars": 1000,
  "minVolume": 100,
  "maxItems": 500,
  "pageSize": 1000
}
```

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `marketTickers` | string\[] | empty | Fetch up to 100 exact Kalshi market tickers |
| `eventTicker` | string | empty | Restrict catalog results to one parent event |
| `seriesTicker` | string | empty | Restrict catalog results to one recurring series |
| `status` | string | `open` | `open`, `closed`, `settled`, or `all` |
| `keyword` | string | empty | Match ticker, event ticker, title, or outcome labels |
| `minCloseTime` | ISO string | empty | Earliest accepted close timestamp |
| `maxCloseTime` | ISO string | empty | Latest accepted close timestamp |
| `minLiquidityDollars` | number | `0` | Minimum reported dollar liquidity |
| `minVolume` | number | `0` | Minimum reported total volume |
| `minOpenInterest` | number | `0` | Minimum reported open interest |
| `includeEventDetails` | boolean | `false` | Add cached event/category/series context |
| `maxItems` | integer | `25` | Maximum market records saved |
| `pageSize` | integer | `100` | Source records requested per cursor page |
| `maxPages` | integer | `25` | Maximum cursor pages scanned |

Exact ticker lookups still apply keyword and numeric filters.

Set `status` to `all` when retrieving an exact ticker whose lifecycle state is unknown.

### Output example

```json
{
  "ticker": "KXHIGHNY-26JUL19-T88",
  "eventTicker": "KXHIGHNY-26JUL19",
  "seriesTicker": "KXHIGHNY",
  "title": "Will the high temperature in NYC be 88° or above?",
  "status": "active",
  "category": "Climate and Weather",
  "yesBid": 0.42,
  "yesAsk": 0.45,
  "noBid": 0.55,
  "noAsk": 0.58,
  "lastPrice": 0.44,
  "liquidity": 1250.5,
  "volume": 4821,
  "openInterest": 761,
  "closeTime": "2026-07-20T03:00:00Z",
  "marketUrl": "https://kalshi.com/markets/...",
  "sourceApiUrl": "https://api.elections.kalshi.com/trade-api/v2/markets?...",
  "scrapedAt": "2026-07-19T12:00:00.000Z"
}
```

Fields that Kalshi does not provide for a contract are omitted instead of emitted as misleading zeroes or nulls.

`rawJson` contains the original market object for advanced users.

### Filter behavior and result scope

Source-side filters—status, event, series, and close-time bounds—are sent to Kalshi.

Keyword, liquidity, volume, and open-interest filters are applied locally to returned market records.

When a numeric filter is enabled, a missing or unparseable source value does **not** pass the filter.

That fail-closed behavior prevents unknown liquidity from being treated as sufficient liquidity.

`maxPages` bounds selective scans.

Increase it if a rare keyword or high threshold returns fewer records than expected.

### Tips for best results

- 🚀 Start with 10–25 markets to inspect the schema cheaply.
- 🎯 Prefer a series or event ticker when you know the target.
- 🔍 Use a larger `pageSize` for selective keyword or liquidity scans.
- 🧾 Enable event details only when category or settlement-source context is needed.
- 🕒 Schedule identical inputs to create comparable snapshots over time.
- 🧮 Treat prices as contract-dollar values between 0 and 1, not percentages.
- 📦 Keep `rawJson` when your pipeline must survive future Kalshi field additions.
- ⚠️ Market data changes quickly; use `scrapedAt` to identify snapshot age.

### Integrations and monitoring workflows

**Kalshi Markets Scraper → Google Sheets**

Schedule an open-market scan and append quote, volume, and close-time columns for an analyst-friendly dashboard.

**Kalshi Markets Scraper → Slack or Discord**

Use an Apify webhook or Make scenario to alert when downstream logic finds high volume or a large probability move.

**Kalshi Markets Scraper → BigQuery, Snowflake, or PostgreSQL**

Store timestamped contract snapshots for research, model features, and historical comparisons.

**Kalshi Markets Scraper → Make or Zapier**

Start a run on a schedule, filter dataset items, then create notifications, spreadsheet rows, or database records.

**Kalshi Markets Scraper → Python notebook**

Pull the dataset with `apify-client`, group by category or event, and analyze spreads and market activity.

### Using the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kalshi-markets-scraper').call({
  status: 'open',
  minLiquidityDollars: 1000,
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/kalshi-markets-scraper').call(run_input={
    'seriesTicker': 'KXHIGHNY',
    'status': 'open',
    'includeEventDetails': True,
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~kalshi-markets-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"status":"open","maxItems":25}'
```

Use the returned run ID to inspect status and retrieve the default dataset.

Never put a long-lived token in public source code.

### Use with AI agents via MCP

Kalshi Markets Scraper can be called by AI assistants through Apify's hosted [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp) server.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/kalshi-markets-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/kalshi-markets-scraper"
    }
  }
}
```

Authenticate with your Apify account when prompted.

Example prompts:

- “Use `automation-lab/kalshi-markets-scraper` to export 100 open markets with at least $1,000 liquidity.”
- “Get active contracts for Kalshi series KXHIGHNY and include event details.”
- “Create a current Kalshi odds snapshot that I can compare with tomorrow's run.”

### Data quality and source notes

This Actor reads Kalshi's public Trade API.

Market status values in output are preserved from the source; for example, an input status of `open` can correspond to source status `active`.

Dollar fields are parsed from Kalshi fixed-point strings.

The original record remains available in `rawJson`.

Market URLs are constructed from source tickers for convenience.

Kalshi may add, rename, or omit fields as its API evolves.

### Is it legal to scrape Kalshi market data?

This Actor accesses publicly available market data without bypassing authentication or technical restrictions.

Scraping public information is generally lawful in many jurisdictions, but permitted use depends on your location, purpose, Kalshi's terms, and applicable financial-data rules.

Do not use the Actor to manipulate markets, misrepresent stale information, violate privacy, or breach contractual restrictions.

You are responsible for complying with Kalshi's terms, the Kalshi Developer Agreement, and applicable law.

This Actor is an independent data tool and is not affiliated with or endorsed by Kalshi.

### Frequently asked questions

**Does this Actor place trades or access my Kalshi account?**

No. It only reads public market metadata. It never requests account credentials and cannot place orders.

**How fast is a run?**

A small snapshot usually needs only one public JSON request. Event enrichment adds one request per unique parent event, so enriched runs take longer.

**Why are some optional fields absent?**

Kalshi does not populate every field for every market type or lifecycle state. Missing source values are omitted rather than fabricated.

**Why did a keyword scan return fewer markets than requested?**

Keyword filtering happens after source pages arrive. Increase `maxPages`, use a broader keyword, or target a known event or series ticker.

**Why did an exact ticker fail?**

Check spelling and use the complete market ticker, not only an event or series ticker. Set `status` to `all` if you also apply lifecycle filtering downstream.

**How are probabilities represented?**

Quote prices are decimal contract-dollar values from 0 to 1. A YES ask of `0.63` is commonly interpreted as an implied 63% market price before spread and fees.

**How is this different from Kalshi's official API?**

The Actor wraps public endpoints with validation, pagination, normalization, Apify datasets, exports, schedules, webhooks, API clients, and MCP access.

**Can I export settled markets?**

Yes. Set `status` to `settled`, then optionally narrow by event, series, close window, keyword, or exact ticker.

### Other prediction-market scrapers

Explore related Actors maintained by `automation-lab`:

- [Polymarket Markets Scraper](https://apify.com/automation-lab/polymarket-markets-scraper) — public Polymarket contracts and odds
- [Polymarket Leaderboard Scraper](https://apify.com/automation-lab/polymarket-leaderboard-scraper) — ranked trader performance
- [Polymarket Wallet Portfolio and Trade History Scraper](https://apify.com/automation-lab/polymarket-wallet-portfolio-trade-history-scraper) — wallet positions and activity
- [Kalshi Trader Social Profile Scraper](https://apify.com/automation-lab/kalshi-trader-social-profile-scraper) — public trader profiles and social activity
- [Limitless Prediction Markets Scraper](https://apify.com/automation-lab/limitless-prediction-markets-scraper) — another prediction-market catalog

For Kalshi contract-level snapshots, use this Actor. For trader-level identity or portfolio workflows, choose the related specialist Actor.

### Support

Open an issue on the Actor page with:

- the input that produced the problem;
- the run URL;
- the expected market or ticker;
- whether the issue is repeatable.

Do not include private credentials or sensitive trading information.

The run log reports page counts, matched records, saved records, retries, and enrichment activity to help diagnose source changes.

# Actor input Schema

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

Add up to 100 exact Kalshi market tickers. Leave empty to browse the market catalog.

## `eventTicker` (type: `string`):

Limit catalog results to one parent event ticker, for example KXHIGHNY-26JUL19.

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

Limit catalog results to a recurring Kalshi series, for example KXHIGHNY.

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

Choose open, closed, settled, or all public contracts.

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

Keep contracts whose ticker, title, event ticker, or outcome labels contain this text. The scraper scans up to the configured page limit.

## `minCloseTime` (type: `string`):

Only request markets closing at or after this ISO-8601 date/time.

## `maxCloseTime` (type: `string`):

Only request markets closing at or before this ISO-8601 date/time.

## `minLiquidityDollars` (type: `number`):

Keep markets with at least this much reported Kalshi liquidity.

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

Keep markets with at least this many reported contracts traded.

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

Keep markets with at least this much reported open interest.

## `includeEventDetails` (type: `boolean`):

Enrich each unique event with category, series ticker, event title, exclusivity, and settlement sources. This makes one extra API request per unique event.

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

Stop after saving this many market contracts.

## `pageSize` (type: `integer`):

Request this many source records per cursor page. Larger pages are faster for selective local filters.

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

Stop local keyword or liquidity filtering after this many cursor pages, even if fewer markets match.

## Actor input object example

```json
{
  "status": "open",
  "minLiquidityDollars": 0,
  "minVolume": 0,
  "minOpenInterest": 0,
  "includeEventDetails": false,
  "maxItems": 10,
  "pageSize": 20,
  "maxPages": 5
}
```

# 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 = {
    "status": "open",
    "minLiquidityDollars": 0,
    "minVolume": 0,
    "minOpenInterest": 0,
    "includeEventDetails": false,
    "maxItems": 10,
    "pageSize": 20,
    "maxPages": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "status": "open",
    "minLiquidityDollars": 0,
    "minVolume": 0,
    "minOpenInterest": 0,
    "includeEventDetails": False,
    "maxItems": 10,
    "pageSize": 20,
    "maxPages": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kalshi-markets-scraper").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 '{
  "status": "open",
  "minLiquidityDollars": 0,
  "minVolume": 0,
  "minOpenInterest": 0,
  "includeEventDetails": false,
  "maxItems": 10,
  "pageSize": 20,
  "maxPages": 5
}' |
apify call automation-lab/kalshi-markets-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kalshi Markets Scraper",
        "description": "Export Kalshi prediction markets, odds, bids, asks, liquidity, volume, open interest, dates, outcomes, and rules. No login required; schedule runs or use the API.",
        "version": "0.1",
        "x-build-id": "dfyKJCgF5KrG5h0lx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kalshi-markets-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-kalshi-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~kalshi-markets-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-kalshi-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~kalshi-markets-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-kalshi-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "marketTickers": {
                        "title": "🎯 Exact market tickers",
                        "type": "array",
                        "description": "Add up to 100 exact Kalshi market tickers. Leave empty to browse the market catalog.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "eventTicker": {
                        "title": "Event ticker",
                        "type": "string",
                        "description": "Limit catalog results to one parent event ticker, for example KXHIGHNY-26JUL19."
                    },
                    "seriesTicker": {
                        "title": "Series ticker",
                        "type": "string",
                        "description": "Limit catalog results to a recurring Kalshi series, for example KXHIGHNY."
                    },
                    "status": {
                        "title": "Market status",
                        "enum": [
                            "open",
                            "closed",
                            "settled",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose open, closed, settled, or all public contracts.",
                        "default": "open"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Keep contracts whose ticker, title, event ticker, or outcome labels contain this text. The scraper scans up to the configured page limit."
                    },
                    "minCloseTime": {
                        "title": "Earliest close time",
                        "type": "string",
                        "description": "Only request markets closing at or after this ISO-8601 date/time."
                    },
                    "maxCloseTime": {
                        "title": "Latest close time",
                        "type": "string",
                        "description": "Only request markets closing at or before this ISO-8601 date/time."
                    },
                    "minLiquidityDollars": {
                        "title": "Minimum liquidity (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep markets with at least this much reported Kalshi liquidity.",
                        "default": 0
                    },
                    "minVolume": {
                        "title": "Minimum total volume",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep markets with at least this many reported contracts traded.",
                        "default": 0
                    },
                    "minOpenInterest": {
                        "title": "Minimum open interest",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep markets with at least this much reported open interest.",
                        "default": 0
                    },
                    "includeEventDetails": {
                        "title": "Add event details",
                        "type": "boolean",
                        "description": "Enrich each unique event with category, series ticker, event title, exclusivity, and settlement sources. This makes one extra API request per unique event.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum markets",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many market contracts.",
                        "default": 25
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Request this many source records per cursor page. Larger pages are faster for selective local filters.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum pages to scan",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Stop local keyword or liquidity filtering after this many cursor pages, even if fewer markets match.",
                        "default": 25
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```