# Kalshi Scraper | Prediction Market API (`parsebird/kalshi-scraper`) Actor
Extract prediction market data from Kalshi: series, events, markets, prices, volume, and resolution rules. Search by keyword or paste Kalshi market URLs.
- **URL**: https://apify.com/parsebird/kalshi-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Automation, News, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.80 / 1,000 market scrapeds
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 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 Scraper | Prediction Market API
Extract prediction market data from [Kalshi](https://kalshi.com), the CFTC-regulated U.S. prediction market exchange. The **Kalshi Scraper** searches by keyword or reads individual market/event URLs directly, returning structured data on series, events, markets, prices, volume, and resolution rules.
Search Kalshi by keyword across every category — politics, economics, sports, crypto — or pull a specific market's live yes/no pricing, volume, settlement timing, and full resolution rules from its URL.
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
```
Apify Actor: parsebird/kalshi-scraper. Scrapes prediction market data from Kalshi (kalshi.com), the CFTC-regulated U.S. prediction market exchange. Call via ApifyClient: client.actor("parsebird/kalshi-scraper").call(run_input={"searchQueries": ["inflation"], "maxResults": 50}). Also accepts startUrls/targetUrls/targetUrl (Kalshi search URLs or individual market/event URLs), pageSize (items per API call, 1-100), and proxyConfiguration. Search results return series/event-grouped records: query, sourceUrl, series_ticker, series_title, event_ticker, event_title, category, total_volume, active_market_count, markets[] (ticker, yes_bid, yes_ask, last_price, volume), tags. Direct listing URLs return flattened per-market records: ticker, series_ticker, event_ticker, title, subtitle, description, categories, market_type, status, yes_price, no_price, last_trade_price, volume, settlement_timing, resolution_source, rules, created_at, close_date. Full API spec: https://apify.com/parsebird/kalshi-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```
### What does Kalshi Scraper do?
This actor calls Kalshi's own public search and trading APIs directly — no browser, no HTML scraping, no rate-limit guesswork. You give it a keyword, a Kalshi search URL, or a specific market/event URL, and it returns structured pricing, volume, and resolution data.
- 🔍 **Multi-keyword search** — run several search terms in one job; each query's results are tagged so you know which term surfaced them.
- 🔗 **Direct market and event URLs** — paste a Kalshi listing URL to pull one specific market, or an event URL to pull every market under that event (e.g. all strike-price variants of the same question).
- 🔎 **Search-URL support** — paste a `kalshi.com/markets?search=...` URL directly and it's parsed into the equivalent keyword search.
- 💰 **Live pricing and volume** — yes/no bid/ask, last traded price, and volume for every market.
- 📜 **Full resolution details** — settlement timing, resolution/settlement sources, and complete primary/secondary rules text.
- 📄 **Configurable pagination** — control page size (up to 100 per call) and a per-query result cap independently.
### What data can you extract from Kalshi?
| Field | Description |
|-------|-------------|
| `series_ticker` / `event_ticker` / `ticker` | Kalshi identifiers you can map back to the exchange |
| `title` / `subtitle` / `description` | Human-readable market copy |
| `category` / `tags` | Classification (Politics, Sports, Economics, Crypto, etc.) |
| `yes_price` / `no_price` / `last_trade_price` | Current market pricing |
| `volume` | Trading volume |
| `status` / `market_type` | Lifecycle status and contract type (e.g. `binary`) |
| `settlement_timing` / `resolution_source` / `rules` | How and when the contract resolves |
| `close_date` / `open_date` / `expiration_date` | Key lifecycle timestamps |
Search results return a series/event-grouped shape with a nested `markets[]` array (matching Kalshi's own search API); direct listing URLs return one flattened record per market. See the [full field reference](https://apify.com/parsebird/kalshi-scraper/input-schema) for both shapes.
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQueries` | array | No | `["new york"]` | Keywords to search; each query runs independently |
| `startUrls` | array | No | — | Kalshi search URLs or individual market/event URLs |
| `targetUrl` | string | No | — | Single Kalshi URL for quick one-off pulls |
| `targetUrls` | array | No | — | Alias of `startUrls` |
| `maxResults` | integer | No | `200` | Maximum markets to save per query |
| `pageSize` | integer | No | `min(maxResults, 50)` | Items fetched per API call (1–100) |
| `proxyConfiguration` | object | No | Off | Optional Apify Proxy settings |
### Output example
```json
{
"query": "new york",
"sourceUrl": "https://api.elections.kalshi.com/v1/search/series",
"type": "contract",
"series_ticker": "GOVPARTYNY",
"series_title": "New York Governor",
"event_ticker": "GOVPARTYNY-26",
"event_title": "New York Governor winner?",
"category": "Elections",
"total_volume": 295509,
"active_market_count": 2,
"markets": [
{
"ticker": "GOVPARTYNY-26-D",
"yes_subtitle": "Democratic party",
"yes_bid": 89,
"yes_ask": 90,
"last_price": 89,
"volume": 223875
}
],
"tags": ["US Elections", "Governor"]
}
```
Download results as **JSON, CSV, Excel, HTML, or XML** directly from the Apify Console, or fetch them via the [Apify API](https://docs.apify.com/api/v2) / [dataset endpoint](https://apify.com/parsebird/kalshi-scraper/api).
### Use cases
- **Market monitoring** — track pricing and volume shifts on specific Kalshi markets over time.
- **Sentiment and forecasting research** — use live yes/no pricing as a real-time probability signal for politics, economics, or sports questions.
- **Cross-market analysis** — pull every market under an event (e.g. all outcome variants of one question) in a single call.
- **Content and newsletter automation** — surface trending markets by keyword for a newsletter or trading dashboard.
- **Rules and compliance research** — pull full settlement rules and resolution sources for due diligence.
### How to scrape Kalshi prediction markets
1. **Set your search** — add one or more Search Queries, or paste Kalshi URLs into Start URLs / Target URL.
2. **Set limits** — Max Results caps markets saved per query; Page Size controls API call batching.
3. **(Optional) add a proxy** — enable Apify Proxy under Proxy Configuration for larger or repeated runs.
4. **Run the actor** — click **Start** in the Apify Console, or trigger it via the [API](https://docs.apify.com/api/v2) or on a [schedule](https://docs.apify.com/platform/schedules).
5. **Get your data** — download the dataset as JSON/CSV/Excel, or pull it via the API.
### How much does it cost to scrape Kalshi?
This actor uses [Pay-Per-Event (PPE)](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) pricing — you're charged per market/series record extracted, not per compute unit.
| Event | Price per event | Price per 1,000 |
|-------|----------------|-----------------|
| `market-scraped` (Free plan) | $0.0009 | **$0.90** |
| `market-scraped` (Bronze / Silver / Gold plans) | $0.0008 | **$0.80** |
A run collecting 1,000 records costs roughly $0.80–$0.90 depending on your Apify plan. All Apify accounts include a [free trial](https://apify.com/pricing) with credits to try the actor before committing to a paid plan.
### FAQ
**Why do search results and listing-URL results look different?**
Search results mirror Kalshi's own search API, which groups markets under their parent series/event with a nested `markets[]` array. Listing URLs (a specific market or event page) return one flattened record per market instead, since you're already targeting a specific contract.
**What happens if I paste an event URL instead of a market URL?**
The actor detects whether the last URL segment resolves to a single market or an event, and if it's an event, returns one record per market under that event (e.g. every strike-price variant of the same question).
**What happens if a market has expired or settled?**
Kalshi removes expired/settled markets from its API after a period. If a Start URL points to a market that's no longer available, the actor logs a warning and skips it rather than failing the run.
**Are prices in cents or dollars?**
Search results return Kalshi's raw pricing fields as-is (cents, e.g. `"yes_bid": 89`). Direct listing URL results normalize pricing to dollars (e.g. `"yes_price": 0.89`) to match the documented field names.
**Does this actor support scheduling and integrations?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run it daily or weekly, connect it to [Zapier, Make, or Slack](https://apify.com/integrations), or call it through the [Apify API](https://docs.apify.com/api/v2) from your own backend.
### Is it legal to scrape Kalshi?
Yes. This actor only accesses publicly available market data that Kalshi makes visible via its own public API. It does not bypass login walls, place trades, or access private account data. Scraping publicly available data is generally considered legal — see [Apify's overview of web scraping legality](https://www.apify.com/is-web-scraping-legal) for more detail. Users are responsible for ensuring their use of the collected data complies with applicable laws and [Kalshi's Terms of Service](https://kalshi.com/terms-of-service). This actor is not affiliated with or endorsed by Kalshi and does not provide financial or investment advice.
### Python and JavaScript usage
**Python** ([apify-client](https://docs.apify.com/api/client/python/)):
```python
from apify_client import ApifyClient
client = ApifyClient("")
run_input = {
"searchQueries": ["inflation"],
"maxResults": 50,
}
run = client.actor("parsebird/kalshi-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item.get("event_title") or item.get("title"))
```
**JavaScript** ([apify-client](https://docs.apify.com/api/client/js/)):
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '' });
const input = {
searchQueries: ['inflation'],
maxResults: 50,
};
const run = await client.actor('parsebird/kalshi-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
### Related Actors
- [Polymarket Leaderboard Scraper](https://apify.com/parsebird/polymarket-scraper) — trader rankings from Polymarket
- [Polymarket Market Scraper](https://apify.com/parsebird/polymarket-market-scraper) — market data from Polymarket
- [Polymarket Rewards Scraper](https://apify.com/parsebird/polymarket-rewards-scraper) — liquidity rewards data from Polymarket
Browse the full catalog on the [ParseBird Apify Store page](https://apify.com/parsebird).
# Actor input Schema
## `searchQueries` (type: `array`):
Keywords to search on Kalshi. Each query runs independently and results are tagged with the query that found them.
## `startUrls` (type: `array`):
Kalshi URLs to process. Supports search URLs (kalshi.com/markets?search=...) and individual market/event listing URLs.
## `targetUrl` (type: `string`):
Single Kalshi URL, handy for quick one-off pulls.
## `targetUrls` (type: `array`):
Alias of Start URLs for convenience.
## `maxResults` (type: `integer`):
Maximum markets to save per query.
## `pageSize` (type: `integer`):
Items fetched per API call (capped between 1 and 100). Defaults to min(maxResults, 50).
## `proxyConfiguration` (type: `object`):
Optional Apify Proxy settings, or bring your own. Kalshi's public API doesn't require a proxy for normal use.
## Actor input object example
```json
{
"searchQueries": [
"new york"
],
"startUrls": [],
"targetUrls": [],
"maxResults": 50,
"proxyConfiguration": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `dataset` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchQueries": [
"new york"
],
"startUrls": [],
"targetUrls": [],
"maxResults": 50,
"proxyConfiguration": {
"useApifyProxy": false
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchQueries": ["new york"],
"startUrls": [],
"targetUrls": [],
"maxResults": 50,
"proxyConfiguration": { "useApifyProxy": False },
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/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 '{
"searchQueries": [
"new york"
],
"startUrls": [],
"targetUrls": [],
"maxResults": 50,
"proxyConfiguration": {
"useApifyProxy": false
}
}' |
apify call parsebird/kalshi-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/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 ` 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/fsPGKBpXN56wDEw6D/builds/58R1kgQghB2409kz6/openapi.json