# Polymarket & Kalshi Scraper: Odds, Price History, Results (`sports-odds-lab/polymarket-kalshi-odds`) Actor

Polymarket and Kalshi odds in one schema: implied probability, bid/ask, 24h change, volume, liquidity, open interest, close time, category. Resolved markets with results, full Kalshi series history back to 2021, daily or hourly price history, rules. Official public APIs, no login.

- **URL**: https://apify.com/sports-odds-lab/polymarket-kalshi-odds.md
- **Developed by:** [Sports Odds Lab](https://apify.com/sports-odds-lab) (community)
- **Categories:** Agents, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Polymarket & Kalshi Scraper: Odds, Price History, Results

> 🎁 **Free until 9 October 2026.** Press **Start** — the prefilled input returns the 100 most traded markets of both platforms in under a minute.

Get **prediction market odds from Polymarket and Kalshi in one clean table** — the implied probability of every market, bid and ask, 24-hour change, volume, liquidity, open interest, closing time and category. Switch to **resolved markets** to get the result of each one, add **price history** (daily over the market's life or hourly for the last week) and the **resolution rules**.

Both platforms are read through their **official public APIs** — no account, no login, no browser, no proxy. Runs are fast (a full scan of both platforms takes well under a minute) and cheap.

📚 **Full Kalshi history of any series**: list a series such as `KXFED` and get every market it ever had — including the ones Kalshi has moved to its archive — with results and daily price history. For the Fed that is **660 markets from July 2021 to today** in under three minutes.

### What you get for each market

- **Market**: platform, event ("Fed decision in October?"), the market question, the outcome it refers to ("25 bps decrease", a team, "Above 4.25%"), link, category and tags
- **Price**: implied **probability** (0–1), best **bid** and **ask**, spread, last traded price, **24h change**
- **Activity**: total and 24h **volume** (USD on Polymarket, contracts on Kalshi), **liquidity**, **open interest** (Kalshi)
- **Timing**: open time, **close time**
- **Outcome** *(resolved markets)*: the **result** and when it resolved
- **Price history** *(optional)*: probability over time — daily over the market's life (Kalshi: up to a year) or hourly for the last 7 days
- **Rules** *(optional)*: the full resolution rules and source

One schema for both platforms, so you can put Polymarket and Kalshi side by side without writing two integrations.

### Use cases

- **Trading research and arbitrage** — compare the same question on Polymarket and Kalshi, spot the platform that is off, follow the 24h movers
- **Calibration and backtesting** — pull resolved markets with their final prices and results and measure how well the crowd forecasts; a whole Kalshi series (every Fed decision since 2021, every daily NYC temperature market) comes with daily price history
- **News and event monitoring** — track the probability of elections, Fed decisions, economic releases, geopolitics or company events every hour
- **AI agents and dashboards** — a single tool call returns live probabilities for any topic ("what does the market say about…?")
- **Sports** — game and championship odds from Kalshi and Polymarket next to your bookmaker data
- **Weather markets** — daily temperature and rain brackets on Kalshi with their price history

### How to use it

1. Choose the platforms, **Open** or **Resolved** markets, and optionally keywords (`fed rate`, `bitcoin`, `election`) or categories.
2. Pick how to sort (24h volume, total volume, liquidity, closing soonest, newest) and how many markets you want per platform.
3. Click **Start**, then download JSON, CSV or Excel, or read the dataset through the Apify API.

**Tip — a live probability feed:** create a [Schedule](https://docs.apify.com/platform/schedules) that runs every hour with your keywords. Each run is a snapshot you can append to your own database or sheet.

#### Input example — Fed and inflation odds, both platforms

```json
{
  "platforms": ["polymarket", "kalshi"],
  "status": "open",
  "search": ["fed", "inflation", "cpi"],
  "sortBy": "volume24h",
  "maxMarkets": 100
}
```

#### Input example — resolved markets of the last week with daily history

```json
{
  "platforms": ["polymarket", "kalshi"],
  "status": "resolved",
  "resolvedWithinDays": 7,
  "categories": ["politics", "economics"],
  "minVolume": 10000,
  "includePriceHistory": true,
  "historyResolution": "daily",
  "maxMarkets": 1000
}
```

#### Input example — specific markets

```json
{
  "markets": [
    "https://polymarket.com/event/fed-decision-in-october-20260617190323537",
    "KXFED-26OCT"
  ],
  "includePriceHistory": true,
  "historyResolution": "hourly"
}
```

Kalshi accepts a series (`KXFED` — its whole history, archived markets included), an event (`KXFED-26OCT`) or a market ticker; Polymarket an event URL, a market URL or an event slug.

#### Output example

```json
{
  "platform": "kalshi",
  "marketId": "KXFED-26OCT-T4.00",
  "eventId": "KXFED-26OCT",
  "event": "Fed funds rate after Oct 2026 meeting? — On Oct 28, 2026",
  "market": "Will the upper bound of the federal funds rate be above 4.00% following the Fed's Oct 28, 2026 meeting?",
  "outcome": "Above 4.00%",
  "url": "https://kalshi.com/markets/kxfed",
  "category": "economics",
  "tags": ["Economics", "KXFED"],
  "status": "open",
  "probability": 0.645,
  "yesBid": 0.64,
  "yesAsk": 0.65,
  "spread": 0.01,
  "lastPrice": 0.65,
  "priceChange24h": -0.01,
  "volume": 65677.35,
  "volume24h": 1206.68,
  "volumeUnit": "contracts",
  "liquidity": null,
  "openInterest": 33132.8,
  "outcomes": [{"name": "Yes", "price": 0.645, "tokenId": null}, {"name": "No", "price": 0.355, "tokenId": null}],
  "openTime": "2025-08-06T14:30:00Z",
  "closeTime": "2026-10-28T17:55:00Z",
  "result": null,
  "resolvedAt": null,
  "resolutionSource": "Federal Reserve Board of Governors",
  "rules": null,
  "priceHistory": [
    {"time": "2026-09-24T04:00:00Z", "price": 0.64, "volume": 6913.64},
    {"time": "2026-09-25T04:00:00Z", "price": 0.67, "volume": 2597.39}
  ],
  "scrapedAt": "2026-09-25T18:04:37Z"
}
```

The same question on Polymarket (*Fed Decision in October?*) returned `"outcome": "25 bps increase", "probability": 0.625` in the same run — the two platforms side by side.

A resolved Polymarket market looks like `"status": "resolved", "probability": 1.0, "result": "Yes", "resolvedAt": "2026-09-20T16:02:11Z"`. For two-sided markets (a match, over/under) `outcome` names the side that `probability` refers to, and `outcomes` lists both.

### Pricing

📊 **Free until 9 October 2026** — during the launch period you only pay Apify's platform usage, typically well under $0.01 per run.

**From 10 October 2026 you pay per market saved — platform usage included**, nothing else:

| Apify plan | Price per 1,000 markets |
|---|---|
| Free | $2.00 |
| Starter | $1.80 |
| Scale | $1.60 |
| Business and higher | $1.40 |

💡 On Apify's free plan the monthly $5 credit covers about **2,500 markets** — or a few hundred markets with full price history every day for a month. Price history and rules come at no extra cost. Set a spending limit on the run for a hard cap: the Actor stops as soon as it is reached.

### FAQ

**What is "probability"?** The price of the market's Yes side (or of the outcome named in `outcome`), which on both platforms equals the implied probability. It is the midpoint of bid and ask when the spread is at most 10 cents, otherwise the last traded price — the same rule the exchanges use for their displayed odds. Resolved markets show 1 or 0.

**Why are volumes in different units?** Polymarket reports traded USD; Kalshi reports traded contracts (each pays $1). `volumeUnit` says which one a row uses. Sorting and the volume filters compare markets within each platform.

**How fresh is the data?** Live at the time of the run — both APIs are the ones the exchanges' own apps use.

**Do I need a Polymarket or Kalshi account?** No. Only public market data is read.

**How long does a run take?** Open markets of both platforms: under a minute. Resolved markets: Polymarket is quick, while Kalshi settles about 80,000 markets a day (mostly untraded price brackets), so each day of the window adds scanning time — a week takes a few minutes. For the long history of one topic, list its Kalshi series (e.g. `KXFED`) under **Specific markets** instead.

**How many markets are there?** Kalshi lists 100,000+ open markets (many are brackets of the same event), Polymarket several tens of thousands. The default filters skip markets that never traded; use keywords, categories and **Max markets** to keep runs focused.

**Is this financial advice?** No. It is market data for research. This Actor is not affiliated with Polymarket or Kalshi.

### More from Sports Odds Lab

- ⚽ [Football Odds Scraper](https://apify.com/sports-odds-lab/football-odds-results) — 1,000+ competitions, 1X2, over/under, BTTS and Asian handicap, seasons back to 2005
- 🎾 [Tennis Scraper: Live Scores, Results & Odds](https://apify.com/sports-odds-lab/tennis-odds-results) — every ATP, WTA, Challenger and ITF match, odds from 40+ bookmakers back to 2009
- 🏀 [NBA, NFL, MLB & NHL Odds](https://apify.com/sports-odds-lab/nba-nfl-mlb-nhl-odds) — moneyline, spread and total history back to 2009, DraftKings, FanDuel, BetMGM

⭐ **Did this Actor save you time?** A short review on this page helps other traders and researchers find it — and tells us what to build next.

### Changelog

- **0.1** — first release: Polymarket and Kalshi open and resolved markets in one schema, keyword and category filters, specific markets by URL or ticker, full history of Kalshi series (archive included), price history (daily or hourly), resolution rules.

# Actor input Schema

## `platforms` (type: `array`):

Which prediction markets to read. Both use their official public data APIs — no account or login needed.

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

Open markets with live prices, or resolved markets with their result (for calibration studies and backtests).

## `search` (type: `array`):

Only markets whose event, question or outcome contains a keyword (all words of one keyword must appear), e.g. "fed rate", "bitcoin", "election". Leave empty for all.

## `categories` (type: `array`):

Only these categories (one common list for both platforms). Leave empty for all.

## `markets` (type: `array`):

Polymarket event or market URLs (https://polymarket.com/event/…), Kalshi URLs or tickers (series KXFED, event KXFED-26OCT or market ticker). When set, only these are returned and the filters above are ignored.

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

Skip markets that traded less than this in total (USD on Polymarket, contracts on Kalshi). The default 1 skips markets that never traded.

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

Skip markets that traded less than this in the last 24 hours (USD on Polymarket, contracts on Kalshi).

## `endingWithinDays` (type: `integer`):

Open markets only: keep markets that close within this many days (0 = any).

## `resolvedWithinDays` (type: `integer`):

Resolved markets only: markets that closed in this many past days (up to 30). Kalshi settles about 80,000 markets a day, so each day adds scanning time; for the full history of one topic list its series in Specific markets (e.g. KXFED).

## `sortBy` (type: `string`):

Which markets come first (and are kept when Max markets applies). Volumes are compared within each platform.

## `maxMarkets` (type: `integer`):

Stop after this many markets per platform (0 = no limit — Kalshi alone lists 100,000+ open markets).

## `includePriceHistory` (type: `boolean`):

Probability over time for every market: daily over the market's life (Kalshi: up to a year) or hourly for the last 7 days.

## `historyResolution` (type: `string`):

Daily points over the market's whole life (Kalshi: up to a year) or hourly points for the last 7 days. Used only with Include price history.

## `includeRules` (type: `boolean`):

The full rules text of each market (how it resolves and from which source). Long text.

## Actor input object example

```json
{
  "platforms": [
    "polymarket",
    "kalshi"
  ],
  "status": "open",
  "minVolume": 1,
  "minVolume24h": 0,
  "endingWithinDays": 0,
  "resolvedWithinDays": 3,
  "sortBy": "volume24h",
  "maxMarkets": 50,
  "includePriceHistory": false,
  "historyResolution": "daily",
  "includeRules": false
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per market: probability, bid/ask, volume, close time, result.

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

Full records including outcomes, price history and rules.

# 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 = {
    "platforms": [
        "polymarket",
        "kalshi"
    ],
    "maxMarkets": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("sports-odds-lab/polymarket-kalshi-odds").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 = {
    "platforms": [
        "polymarket",
        "kalshi",
    ],
    "maxMarkets": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("sports-odds-lab/polymarket-kalshi-odds").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 '{
  "platforms": [
    "polymarket",
    "kalshi"
  ],
  "maxMarkets": 50
}' |
apify call sports-odds-lab/polymarket-kalshi-odds --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sports-odds-lab/polymarket-kalshi-odds"
        }
    }
}
```

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/DfH4TtSzA7KHcqiRL/builds/D3DnebvP0bhWYFjpZ/openapi.json