# Kalshi Scraper \[Just 💰$0.80/1k] — Odds, Weather & Order Book (`blackfalcondata/kalshi-scraper`) Actor

Kalshi Scraper pulls prediction-market odds from kalshi.com: implied probability, yes/no bid and ask, spread, volume, open interest and settlement results. Covers all ~103,000 tradable markets including weather, plus order book, trades and OHLC candles on request.

- **URL**: https://apify.com/blackfalcondata/kalshi-scraper.md
- **Developed by:** [Black Falcon Data](https://apify.com/blackfalcondata) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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?

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

### What does Kalshi Scraper do?

Kalshi Scraper extracts prediction-market odds from [kalshi.com](https://kalshi.com) — implied probability, yes/no bid and ask, spread, last price, volume, 24h volume and open interest, plus the settlement result once a market resolves. Filter by keyword, series ticker, market status or trading activity, and every row carries the full lifecycle from open to close. Output is structured JSON or CSV, one row per market, so you can run the same query consistently over time.

### How to use this actor

- 👉 **Register for a free Apify account** — no credit card required.
- 🎉 Just click **[Sign up free on Apify →](https://console.apify.com/sign-up?fpr=1h3gvi)** and complete a quick signup.
- 💰 A free Apify account includes $5 in monthly credits — enough to test this actor.
- ⏳ Scrape during the free trial, with no commitment or upfront payment required.

### Key features

- **🔔 Notifications:** Telegram, Slack, Discord, WhatsApp Cloud API, and generic webhook out of the box. Pair with incremental for daily new-listing alerts without pipeline glue.
- **🔗 Paste-mode:** paste any kalshi URL straight from your browser — single-listing pages, search-results URLs, or category SEO URLs. Mix freely with keyword and IDs in the same run; results dedupe by ID.
- **📦 Compact mode:** AI-agent and MCP-friendly payloads with core fields only.
- **📌 Change classification:** each record carries a `changeType` of NEW / UPDATED / UNCHANGED / REAPPEARED / EXPIRED. Default emits NEW + UPDATED + REAPPEARED; opt into the others with `emitUnchanged` / `emitExpired`.
- **🔌 MCP connectors:** export your results into Notion via Apify's MCP connectors — a clean run-summary page, no glue code. Opt-in via the App connector field; deterministic field-mapping, no AI. Built on Apify's connector framework, so more destinations open up as their catalog grows.
- **📝 Description format selection:** pick a single description representation — `text`, `html`, or `markdown` — and the unused variants are dropped from each record. Halves payload size when your pipeline only consumes one format.
- **♻️ Incremental mode:** recurring runs emit and charge only for listings that are new or whose tracked content changed. First run builds the baseline; subsequent runs emit only NEW / UPDATED / REAPPEARED records (UNCHANGED + EXPIRED opt-in). Saves 80–95% on daily monitoring.
- **🧹 Empty-field stripping:** drop null, empty-string, and empty-array fields from each record before push. Smaller payloads for AI agents and dashboards that already handle missing fields gracefully.
- **📤 Export anywhere:** Download the dataset as JSON, CSV, or Excel from the Apify Console, or stream live via the Apify API and integrations (Make, Zapier, Google Sheets, n8n, …).

### What data can you extract from kalshi.com?

Each result includes Core listing fields (`ticker`, `eventTicker`, `title`, `status`, `result`, `marketUrl`, `portalUrl`, and `yesSubtitle`, and more) and extended fields (`detailFetched`). In standard mode, all fields are always present — unavailable data points are returned as `null`, never omitted. In compact mode, only core fields are returned.

### Input

The main inputs are a search keyword and a result limit. Additional filters and options are available in the input schema.

Key parameters:

- **`query`** — Keyword to match against the market question, both outcome subtitles and the tickers (case-insensitive substring). Leave empty to browse every open market, or combine with Series ticker to browse one series.
- **`seriesTicker`** — Return only markets from one series, e.g. `KXFED` (Fed funds rate), `KXNFLGAME` (NFL games), `KXBIGGESTQUAKE` (daily earthquakes). Leave empty to return the whole open-market feed. For several series at once, paste a JSON array: \["KXFED","KXNFLGAME"].
- **`category`** — Return only markets in this category. The exchange indexes its series by category, so the actor asks it for that category's series and fetches only those — it does not scan the whole feed and discard the rest. Typing a close variant works too ("weather" finds Climate and Weather); an unrecognised one stops the run and lists the valid names rather than returning nothing. (default: `""`)
- **`status`** — Which markets to return. Was previously fixed to "open", which put closed and settled markets — the whole historical and settlement use case — out of reach. (default: `"open"`)
- **`excludeMultivariate`** — Kalshi auto-generates enormous numbers of multi-leg parlay markets (KXMVECROSSCATEGORY…). Measured on the live feed they are 98.6% of all open markets and almost none of them trade. On by default so a run returns markets a person recognises. (default: `true`)
- **`minVolume24h`** — Drop markets that traded fewer than this many contracts in the last 24h. Use 1 to keep only markets that traded at all today.
- **`minVolume`** — Drop markets with less total volume than this.
- **`minOpenInterest`** — Outstanding contracts. A better liveness signal than volume — it says money is still at risk, not merely that a trade once happened.
- **`minLiquidity`** — Resting order-book depth in dollars. Note: the open-markets feed reports 0 here for most markets, so a non-zero value filters hard.
- **`maxResults`** — Maximum number of markets to return. The exchange carries about 103,000 tradable markets and 0 returns all of them, which is a long run — a measured run delivered 30,000 in 55 minutes, and how long a full sweep takes varies a great deal from run to run. Most of the exchange is auto-generated combination markets, which are excluded by default, so narrowing by Category or Series Ticker is what makes a large run quick. (default: `200`)
- **`includeOrderBook`** — Resting bids on both sides, with best price and total depth. COSTS ONE EXTRA REQUEST PER MARKET returned — a 1,000-row run is 1,000 extra requests. (default: `false`)
- **`orderBookDepth`** — Price levels per side. Only used when the order book is on. (default: `10`)
- ...and 27 more parameters

### Input examples

**Basic search** — Keyword-driven search with a result cap.

→ Full payload per result — all standard fields populated where the source provides them.

```json
{
  "query": "fed",
  "maxResults": 50
}
```

**Incremental tracking** — Only emit listings that changed since the previous run with this `stateKey`.

→ First run builds the baseline state. Subsequent runs emit only records that are new or whose tracked content changed. Set `emitUnchanged: true` to include unchanged records as well.

```json
{
  "query": "fed",
  "maxResults": 200,
  "incrementalMode": true,
  "stateKey": "fed-tracker"
}
```

**Compact filtered output** — Combine filters with compact mode for a lightweight AI-agent or MCP data source.

→ Core fields only — ideal for piping into LLMs or downstream tools without token overhead.

```json
{
  "query": "fed",
  "category": "weather",
  "maxResults": 50,
  "compact": true
}
```

### Output

Each run produces a dataset of structured listing records. Results can be downloaded as JSON, CSV, or Excel from the Dataset tab in Apify Console.

### Example listing record

```json
{
  "ticker": "KXFED-27APR-T4.25",
  "eventTicker": "KXFED-27APR",
  "title": "Will the upper bound of the federal funds rate be above 4.25% following the Fed's Apr 28, 2027 meeting?",
  "status": "active",
  "marketUrl": "https://kalshi.com/markets/kxfed",
  "portalUrl": "https://kalshi.com/markets/kxfed",
  "sourceApiUrl": "https://api.elections.kalshi.com/trade-api/v2/markets/KXFED-27APR-T4.25",
  "yesSubtitle": "Above 4.25%",
  "noSubtitle": "Above 4.25%",
  "marketType": "binary",
  "rulesSecondary": "This market will expire the first 2:05 PM ET following the release of a Federal Reserve statement for their Apr 28, 2027 meeting or one week following the last day of that meeting.",
  "yesBid": 0.15,
  "yesAsk": 0.27,
  "noBid": 0.73,
  "noAsk": 0.85,
  "yesBidSize": 23.25,
  "yesAskSize": 1,
  "lastPrice": 0.37,
  "previousPrice": 0.35,
  "midPrice": 0.21,
  "spread": 0.12,
  "impliedProbability": 0.21,
  "priceChange": 0.02,
  "hoursToClose": 5613.75,
  "previousYesBid": 0.15,
  "previousYesAsk": 0.35,
  "liquidity": 0,
  "volume": 10293.97,
  "volume24h": 30,
  "openInterest": 2054.01,
  "notionalValue": 1,
  "openTime": "2025-10-13T14:00:00Z",
  "closeTime": "2027-04-28T17:55:00Z",
  "expirationTime": "2027-05-05T18:05:00Z",
  "expectedExpirationTime": "2027-04-28T18:05:00Z",
  "latestExpirationTime": "2027-05-05T18:05:00Z",
  "createdTime": "2025-10-06T19:22:55.893694Z",
  "updatedTime": "2026-04-09T14:07:28.591885Z",
  "canCloseEarly": true,
  "strikeType": "greater",
  "priceLevelStructure": "linear_cent",
  "settlementTimerSeconds": 300,
  "priceRangesJson": "[{\"end\":\"1.0000\",\"start\":\"0.0000\",\"step\":\"0.0100\"}]",
  "rawJson": "{\"can_close_early\":true,\"close_time\":\"2027-04-28T17:55:00Z\",\"created_time\":\"2025-10-06T19:22:55.893694Z\",\"event_ticker\":\"KXFED-27APR\",\"exchange_index\":0,\"expected_expiration_time\":\"2027-04-28T18:05:00...",
  "listingId": "209025d283c829b97a89ca786084410fe95c7d34e97a6c500a8e40a14beab14c",
  "contentQuality": "full",
  "detailFetched": false,
  "scrapedAt": "2026-09-06T20:10:10.585Z",
  "source": "kalshi.com",
  "contentHash": "12ef850ef6c99c9cac8c91c9b8501fff034bdf124a99a480f99b1ef256dae29c"
}
```

### Incremental fields

When incremental mode is on, each record also carries:

- `changeType` — one of `NEW`, `UPDATED`, `UNCHANGED`, `REAPPEARED`, `EXPIRED`. Default output covers `NEW` / `UPDATED` / `REAPPEARED`; set `emitUnchanged: true` or `emitExpired: true` to opt into the others.
- `isRepost`, `repostOfId`, `repostDetectedAt` — populated when a new listing matches the tracked content of a previously expired one. Set `skipReposts: true` to drop detected reposts from the output.

### How to scrape kalshi.com

1. Go to [Kalshi Scraper](https://apify.com/blackfalcondata/kalshi-scraper?fpr=1h3gvi) in Apify Console.
2. Enter a search keyword.
3. Set `maxResults` to control how many results you need.
4. Click **Start** and wait for the run to finish.
5. Export the dataset as JSON, CSV, or Excel.

### Use cases

- Extract listing data from kalshi.com for market research and competitive analysis.
- Track pricing trends across regions and categories over time.
- Monitor new and changed listings on scheduled runs without processing the full dataset every time.
- Feed structured data into AI agents, MCP tools, and automated pipelines using compact mode.
- Export clean, structured data to dashboards, spreadsheets, or data warehouses.

### How much does it cost to scrape kalshi.com?

Kalshi Scraper uses [pay-per-event](https://docs.apify.com/platform/actors/paid-actors/pay-per-event) pricing. You pay a small fee when the run starts and then for each result that is actually produced.

- **Run start:** $0.001 per run
- **Per result:** $0.0008 per listing record

Example costs:

- 10 results: **$0.009**
- 25 results: **$0.021**
- 100 results: **$0.081**
- 200 results: **$0.16**
- 500 results: **$0.4**

#### Example: recurring monitoring savings

These examples compare full re-scrapes with incremental runs at different churn rates. Churn is the share of listings that are new or whose tracked content changed since the previous run. Actual churn depends on your query breadth, source activity, and polling frequency — the scenarios below are examples, not predictions.

Example setup: 250 listings per run, daily polling (30 runs/month). Costs scale linearly with the number of listings.

| Churn rate | Full re-scrape run cost | Incremental run cost | Savings vs full re-scrape | Monthly cost after baseline |
|---|---:|---:|---:|---:|
| 5% — stable niche query | $0.20 | $0.01 | $0.19 (95%) | $0.33 |
| 15% — moderate broad query | $0.20 | $0.03 | $0.17 (85%) | $0.93 |
| 30% — high-volume aggregator | $0.20 | $0.06 | $0.14 (70%) | $1.83 |

Full re-scrape monthly cost at the same cadence: $6.03. First month with incremental costs $0.52 / $1.10 / $1.97 for the 5% / 15% / 30% scenarios because the first run builds baseline state at full cost before incremental savings apply.

Platform usage is included in the per-result fee shown above.

### FAQ

#### How many results can I get from kalshi.com?

The number of results depends on the search query and available listings on kalshi.com. Use the `maxResults` parameter to control how many results are returned per run.

#### Does Kalshi Scraper support recurring monitoring?

Yes. Enable incremental mode to only receive new or changed listings on subsequent runs. This is ideal for scheduled monitoring where you want to track changes over time without re-processing the full dataset.

#### Can I integrate Kalshi Scraper with other apps?

Yes. Kalshi Scraper works with Apify's [integrations](https://apify.com/integrations?fpr=1h3gvi) to connect with tools like Zapier, Make, Google Sheets, Slack, and more. You can also use webhooks to trigger actions when a run completes.

#### Can I use Kalshi Scraper with the Apify API?

Yes. You can start runs, manage inputs, and retrieve results programmatically through the [Apify API](https://docs.apify.com/api/v2). Client libraries are available for JavaScript, Python, and other languages.

#### Can I use Kalshi Scraper through an MCP Server?

Yes. Apify provides an [MCP Server](https://apify.com/apify/actors-mcp-server?fpr=1h3gvi) that lets AI assistants and agents call this actor directly. Use compact mode, a single `descriptionFormat`, and `excludeEmptyFields` to keep payloads manageable for LLM context windows.

#### Is it legal to scrape kalshi.com?

This actor extracts publicly available data from kalshi.com. Web scraping of public information is generally considered legal, but you should always review the target site's terms of service and ensure your use case complies with applicable laws and regulations, including GDPR where relevant.

#### Your feedback

If you have questions, need a feature, or found a bug, please [open an issue](https://apify.com/blackfalcondata/kalshi-scraper/issues?fpr=1h3gvi) on the actor's page in Apify Console. Your feedback helps us improve.

### You might also like

- [DNS Lookup - Bulk DNS Records & DNSSEC](https://apify.com/blackfalcondata/dns-lookup?fpr=1h3gvi) — Bulk DNS record lookup: A, AAAA, MX, TXT, CNAME, NS, SOA and CAA records plus DNSSEC status.
- [Domain Intelligence Scraper](https://apify.com/blackfalcondata/domain-intelligence-scraper?fpr=1h3gvi) — Bulk domain audit — DNS records, WHOIS, SSL certificates, HTTP status, email authentication.
- [Douyin Scraper \[Just 💰$0.5\] — Hot Search, Trending & Viral](https://apify.com/blackfalcondata/douyin-scraper?fpr=1h3gvi) — 💰 $0.50 per 1,000 results. Scrape douyin.com real-time trending boards — hot search, seeding &.
- [eBay Scraper — active & sold listings](https://apify.com/blackfalcondata/ebay-scraper?fpr=1h3gvi) — Scrape ebay.com — active & sold listings with price & condition · item specifics & images · seller.
- [eBay Sold Listings Scraper — final price, date & item](https://apify.com/blackfalcondata/ebay-sold-listings-scraper?fpr=1h3gvi) — Scrape ebay.com completed and sold listings — the final sold price and sold date that vanish.
- [Email Deliverability Checker](https://apify.com/blackfalcondata/email-deliverability-checker?fpr=1h3gvi) — Bulk email deliverability audit: SPF, DMARC, DKIM and DNSSEC records, MX configuration and domain.
- [Facebook Marketplace \[$0.9💰\] Scraper](https://apify.com/blackfalcondata/facebook-marketplace-scraper?fpr=1h3gvi) — Scrape facebook.com Marketplace listings by keyword, category or location with price, condition,.
- [Finn Torget Scraper — Norwegian Marketplace](https://apify.com/blackfalcondata/finn-torget-scraper?fpr=1h3gvi) — Scrape finn.no/torget — Norway's largest classifieds marketplace — filter by category · condition.

### Getting started with Apify

New to Apify? [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=1h3gvi) — no credit card required.

1. Sign up — $5 platform credit included
2. Open this actor and configure your input
3. Click **Start** — export results as JSON, CSV, or Excel

Need more later? [See Apify pricing](https://apify.com/pricing?fpr=1h3gvi).

### Disclaimer

This actor accesses only publicly available data on kalshi.com. You are responsible for how you use the extracted data — in particular any personal information such as names, phone numbers, or email addresses — and for complying with Kalshi's terms of use, applicable data-protection law (including the GDPR where it applies), and the anti-spam rules of your jurisdiction.

This actor is not affiliated with, endorsed by, or connected to Kalshi.

### Search keywords

kalshi scraper, kalshi api, apify kalshi, kalshi data extraction, kalshi.com scraper, kalshi.com data, kalshi.com api, kalshi open, kalshi open scraper, kalshi closed, kalshi closed scraper, kalshi settled, kalshi settled scraper, kalshi unopened, kalshi unopened scraper.

# Actor input Schema

## `query` (type: `string`):

Keyword to match against the market question, both outcome subtitles and the tickers (case-insensitive substring). Leave empty to browse every open market, or combine with Series ticker to browse one series.

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

Return only markets from one series, e.g. `KXFED` (Fed funds rate), `KXNFLGAME` (NFL games), `KXBIGGESTQUAKE` (daily earthquakes). Leave empty to return the whole open-market feed. For several series at once, paste a JSON array: \["KXFED","KXNFLGAME"].

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

Return only markets in this category. The exchange indexes its series by category, so the actor asks it for that category's series and fetches only those — it does not scan the whole feed and discard the rest. Typing a close variant works too ("weather" finds Climate and Weather); an unrecognised one stops the run and lists the valid names rather than returning nothing.

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

Which markets to return. Was previously fixed to "open", which put closed and settled markets — the whole historical and settlement use case — out of reach.

## `excludeMultivariate` (type: `boolean`):

Kalshi auto-generates enormous numbers of multi-leg parlay markets (KXMVECROSSCATEGORY…). Measured on the live feed they are 98.6% of all open markets and almost none of them trade. On by default so a run returns markets a person recognises.

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

Drop markets that traded fewer than this many contracts in the last 24h. Use 1 to keep only markets that traded at all today.

## `minVolume` (type: `integer`):

Drop markets with less total volume than this.

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

Outstanding contracts. A better liveness signal than volume — it says money is still at risk, not merely that a trade once happened.

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

Resting order-book depth in dollars. Note: the open-markets feed reports 0 here for most markets, so a non-zero value filters hard.

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

Maximum number of markets to return. The exchange carries about 103,000 tradable markets and 0 returns all of them, which is a long run — a measured run delivered 30,000 in 55 minutes, and how long a full sweep takes varies a great deal from run to run. Most of the exchange is auto-generated combination markets, which are excluded by default, so narrowing by Category or Series Ticker is what makes a large run quick.

## `includeOrderBook` (type: `boolean`):

Resting bids on both sides, with best price and total depth. COSTS ONE EXTRA REQUEST PER MARKET returned — a 1,000-row run is 1,000 extra requests.

## `orderBookDepth` (type: `integer`):

Price levels per side. Only used when the order book is on.

## `includeTrades` (type: `boolean`):

The public trade tape for each market: time, side, size, price, and whether it was a block trade. No trader identity exists in this data — Kalshi publishes none. COSTS ONE EXTRA REQUEST PER MARKET.

## `tradesLimit` (type: `integer`):

Newest trades to keep per market. Only used when trades are on.

## `includeCandles` (type: `boolean`):

OHLC candles with open interest and volume per period. COSTS ONE EXTRA REQUEST PER MARKET.

## `candleLookbackHours` (type: `integer`):

How far back to fetch OHLC candles, in hours. Long windows at fine periods are split into several requests per market and fetched in sequence, so they work but they take time: 24 hours of hourly candles is one request, while 90 days of 1-minute candles is 26 requests and about 5 seconds for a single market.

## `candlePeriodMinutes` (type: `string`):

Candle size. The exchange supports exactly three: 1 minute, 1 hour and 1 day — anything else is rejected outright. Finer candles over a long lookback mean more requests per market; see Candle Lookback Hours.

## `startUrls` (type: `array`):

One or more direct search or listing detail URLs to process. When set, other search filters are ignored.

## `compact` (type: `boolean`):

Core fields only — ticker, title, status, quote, volume and dates (for AI-agent/MCP workflows).

## `excludeEmptyFields` (type: `boolean`):

Drop null, empty-string, and empty-array fields from each record before push. Smaller payloads for AI agents and dashboards.

## `incrementalMode` (type: `boolean`):

Compare against the previous run and report what is new, what moved, and what closed. stateKey is optional — it defaults to a value derived from the series you are tracking, so different series never share state.

## `stateKey` (type: `string`):

Optional. Stable identifier for the tracked set of markets. Leave empty to auto-generate it from the series you selected.

## `telegramToken` (type: `string`):

Telegram bot token (from @BotFather). Required for Telegram notifications.

## `telegramChatId` (type: `string`):

Telegram chat or channel ID (e.g. "-100123456789"). Required when telegramToken is set.

## `discordWebhookUrl` (type: `string`):

Discord incoming webhook URL. Server Settings → Integrations → Webhooks → New Webhook.

## `slackWebhookUrl` (type: `string`):

Slack incoming webhook URL. api.slack.com/messaging/webhooks.

## `notificationLimit` (type: `integer`):

Maximum number of markets included in each notification message (1–20).

## `notifyOnlyChanges` (type: `boolean`):

When Incremental Mode is on, only send notifications for NEW and UPDATED markets. Has no effect outside incremental mode.

## `whatsappAccessToken` (type: `string`):

WhatsApp Cloud API permanent access token (System User token from Meta Business). Recipient must have messaged the business number within the last 24h (service-conversation window — free since Nov 2024).

## `whatsappPhoneNumberId` (type: `string`):

Your WhatsApp Business phone-number ID (numeric, from Meta dashboard). Required when whatsappAccessToken is set.

## `whatsappTo` (type: `string`):

Recipient phone in E.164 format without + (e.g. "436641234567"). Recipient must have messaged your business number within last 24h.

## `webhookUrl` (type: `string`):

Receives a JSON POST with {metadata, items} after each run. Universal escape hatch for n8n / Make / Zapier / custom backends.

## `webhookHeaders` (type: `object`):

Optional JSON object of custom headers (e.g. {"Authorization":"Bearer ..."}).

## `appConnector` (type: `string`):

Optional. Pick a connected app under Settings → API & Integrations to receive your results. Best-effort across MCP connectors as Apify expands its catalog.

## `mcpIssueTeam` (type: `string`):

Only when the connected app is an issue tracker: the team (name or ID) the summary issue is created under, if that app requires one.

## `descriptionFormat` (type: `string`):

Choose which representation of the listing description to include. `all` keeps every variant; the others keep only the selected one.

## `emitUnchanged` (type: `boolean`):

When incremental mode is on, also emit listings whose content has not changed since the last run. Markets that vanish from the exchange are marked inactive in state but are not emitted as rows.

## `emitExpired` (type: `boolean`):

Also return a row for markets that were in a previous run but are gone now. The row carries the market ticker, when it disappeared and your state key — not a price, because the market is no longer there to have one. Requires Incremental Mode and a run that saw the whole set.

## `skipReposts` (type: `boolean`):

In incremental mode, skip listings that appear to be reposts of a previously-seen expired listing with matching details.

## Actor input object example

```json
{
  "query": "fed",
  "category": "",
  "status": "open",
  "excludeMultivariate": true,
  "maxResults": 200,
  "includeOrderBook": false,
  "orderBookDepth": 10,
  "includeTrades": false,
  "tradesLimit": 20,
  "includeCandles": false,
  "candleLookbackHours": 24,
  "candlePeriodMinutes": "60",
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "notificationLimit": 5,
  "notifyOnlyChanges": false,
  "descriptionFormat": "all",
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": 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 = {
    "query": "fed",
    "status": "open",
    "excludeMultivariate": true,
    "maxResults": 200,
    "includeOrderBook": false,
    "includeTrades": false,
    "includeCandles": false,
    "excludeEmptyFields": false,
    "descriptionFormat": "all",
    "emitExpired": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("blackfalcondata/kalshi-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 = {
    "query": "fed",
    "status": "open",
    "excludeMultivariate": True,
    "maxResults": 200,
    "includeOrderBook": False,
    "includeTrades": False,
    "includeCandles": False,
    "excludeEmptyFields": False,
    "descriptionFormat": "all",
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("blackfalcondata/kalshi-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 '{
  "query": "fed",
  "status": "open",
  "excludeMultivariate": true,
  "maxResults": 200,
  "includeOrderBook": false,
  "includeTrades": false,
  "includeCandles": false,
  "excludeEmptyFields": false,
  "descriptionFormat": "all",
  "emitExpired": false
}' |
apify call blackfalcondata/kalshi-scraper --silent --output-dataset

```

## MCP server setup

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