# Kalshi Scraper & Polymarket Scraper: Odds, Volume (`deriverge/kalshi-polymarket-scraper`) Actor

\[$2.00 / 1K] Kalshi and Polymarket in one schema: question, probability, bid and ask, volume, liquidity, close date, resolution and order book. Official APIs, no key, no browser. Weather preset covers every Kalshi temperature series. Watch mode reports new markets and moves.

- **URL**: https://apify.com/deriverge/kalshi-polymarket-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** News, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 market returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Kalshi & Polymarket Scraper

### What does Kalshi & Polymarket Scraper do?

**Kalshi & Polymarket Scraper** reads **Kalshi** and **Polymarket** and returns both in one schema. Every row is a market: the question, the current probability, best bid and ask, total and 24-hour volume, liquidity, open interest, the close date, the resolution once it settles, the trading rules, and a link to the market. Order books are optional, ten price levels a side by default.

Two exchanges with completely different vocabularies. Kalshi quotes cents-on-the-dollar as strings and keeps the category on the event; Polymarket wraps its arrays in JSON strings and keeps categories in event tags. This actor normalises both, so a query returns one table you can sort by probability or volume without writing glue code.

### Weather markets, which nobody serves reliably

Kalshi runs a daily temperature market for every major American city, the series `KXHIGHNY`, `KXLOWNY` and their siblings. Pick the **Weather** preset and you get every open temperature market with its strike, probability, close time and, once the day is settled, the measured temperature in `settlementValue`. The most-used weather actor in this category currently fails 95 percent of its runs and has not been touched since June. Ours is checked every morning by a scheduled run.

Other presets: Politics and elections, Economics and the Fed, Sports, Crypto, Entertainment.

### Try it without paying

The first two rows of every run are free, on every plan. Run it, look at the output, then decide. You are billed from the third row onward.

### What changed since yesterday

Give the run a watch name or save it as a task, and every run compares itself with the previous snapshot. The `CHANGES` record lists:

- **new markets** that opened since the last run,
- **markets that settled**, with the winning outcome,
- **the biggest probability moves**, every market that moved by five points or more, sorted by size of the move.

Each row also carries `probabilityChange`, the move since the last run, so a scheduled task turns into a movers feed. Comparison costs nothing.

### Input

```json
{
  "exchanges": ["kalshi", "polymarket"],
  "query": "fed rate",
  "categories": ["Economics", "Politics"],
  "status": "open",
  "minVolumeUsd": 10000,
  "closingWithinDays": 90,
  "maxMarkets": 200,
  "includeOrderBook": false,
  "newOnly": false,
  "watchKey": "macro"
}
```

Both exchanges list tens of thousands of markets, most of them automated sports contracts with no volume. `minVolumeUsd` and `closingWithinDays` are the two filters that make the output readable.

### Output

```json
{
  "key": "polymarket:4000554",
  "exchange": "polymarket",
  "marketId": "4000554",
  "question": "Will the Fed cut rates in December?",
  "category": "Economics",
  "tags": ["Economics", "Fed", "Rates"],
  "status": "open",
  "probability": 0.62,
  "probabilityChange": 0.04,
  "yesBid": 0.61,
  "yesAsk": 0.63,
  "outcomes": ["Yes", "No"],
  "outcomePrices": [0.62, 0.38],
  "volumeUsd": 1772232.77,
  "volume24hUsd": 148021.31,
  "liquidityUsd": 155163.59,
  "closesAt": "2026-12-10T17:00:00.000Z",
  "resolvedOutcome": null,
  "url": "https://polymarket.com/event/fed-decision-in-december"
}
```

Probabilities are on a 0 to 1 scale on both exchanges: a Kalshi contract settles at one dollar, so its YES price is the probability directly.

### Pricing

| Event | Price |
|---|---|
| Market returned | $0.004 ($4 per 1,000 markets) |
| Order book snapshot, only when requested | $0.002 |
| Probability move of five points or more since your last run | $0.010 |
| First two rows of every run | **free** |
| Markets removed by filters, markets already seen in new-only mode | **free** |

No start fee. A run that returns nothing costs nothing. For comparison, the most expensive actor in this category charges $0.10 per market record, twenty five times our price, and fails a third of its runs.

### Frequently asked questions

**Where does the data come from?** Kalshi's public trade API and Polymarket's public Gamma and CLOB APIs. Both are official, documented and free, and neither needs a key, a wallet or a login. Nothing is scraped from a web page.

**Why do some Kalshi markets show a probability of zero?** Because nobody has traded them yet and there is no bid or ask. The field is the last price when there is one, otherwise the midpoint, otherwise null. Nothing is guessed.

**Can I compare the same question across both exchanges?** The actor returns both in one table with the same fields, so a filter on a keyword gives you Kalshi and Polymarket side by side. Automatic matching of equivalent contracts is not attempted, because the wording and the resolution rules differ and a wrong match is worse than none.

**How current is it?** Read live at run time. Order books are a snapshot from the moment of the request.

### How to use Kalshi Scraper & Polymarket Scraper

1. Open the actor and fill in `preset` in the input form, or paste the JSON input from the example above.
2. Click **Start**. The first rows appear in the **Output** tab within seconds; the run summary is in the **Storage** tab under the key `SUMMARY`.
3. Download the results as JSON, CSV or Excel from the Output tab, or read them through the API link shown there.
4. To run it on a schedule, click **Save as a task**, set the input once and add a schedule. Scheduled tasks keep their own change snapshot, so the new-only mode works without any extra setup.

### Integrations

The actor is available in the Apify apps for **Make**, **Zapier**, **n8n** and **Keboola**, where you pick it by name and map the input fields. It is also exposed to AI agents through the Apify MCP server, and callable from any language through the Apify API; the API tab on this page has ready-made snippets for Node.js, Python and curl. Every run can post its results to a webhook when it finishes.

### Support

Questions and problems go into the **Issues** tab of this actor. Each issue is answered by the maintainer, and fixes ship as new builds without any change on your side.

Built and operated by deriverge s.r.o. Same rules as our other actors: unified schema, honest billing, no charge for what you did not get.

# Actor input Schema

## `preset` (type: `string`):

A ready-made category filter. Weather selects the Kalshi daily temperature markets (series KXHIGHNY, KXLOWNY and the other cities) plus any Polymarket weather tags. Combine with keywords for a narrower cut.

## `exchanges` (type: `array`):

Which exchanges to read. Leave empty for both.

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

Full-text search on Polymarket and a keyword filter on Kalshi, for example "bitcoin", "election", "fed rate".

## `keywords` (type: `array`):

Keep only markets whose question, subtitle, category or tags contain one of these words.

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

Keep only markets in these categories or tags, for example Politics, Crypto, Sports, Economics.

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

Open markets are still trading; settled markets carry their resolved outcome.

## `minVolumeUsd` (type: `integer`):

Drop thin markets below this lifetime volume. Useful to skip the long tail of automated sports markets.

## `closingWithinDays` (type: `integer`):

Keep only markets that close within this many days. Leave empty for all.

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

Both exchanges list tens of thousands of markets, most of them automated sports contracts. Start small.

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

Adds bids and asks per market. One extra request per market, charged separately.

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

How many price levels per side.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only markets not seen in the previous run. The CHANGES record always lists new markets, settled markets and the biggest probability moves, whether this is on or off.

## `watchKey` (type: `string`):

Name of the snapshot used for change tracking, for example "politics". Runs from a saved task get a snapshot automatically.

## Actor input object example

```json
{
  "exchanges": [
    "kalshi",
    "polymarket"
  ],
  "status": "open",
  "maxMarkets": 200,
  "includeOrderBook": false,
  "orderBookDepth": 10,
  "newOnly": false
}
```

# Actor output Schema

## `markets` (type: `string`):

One row per market from Kalshi and Polymarket in a unified schema: question, probability, bid and ask, volume, liquidity, close date, resolution and optional order book.

## `changes` (type: `string`):

New markets, markets that settled, and the biggest probability moves compared with the previous snapshot.

## `summary` (type: `string`):

Per-exchange counts, how many markets were scanned and how many were returned.

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

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/kalshi-polymarket-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 = { "exchanges": [
        "kalshi",
        "polymarket",
    ] }

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

```

## MCP server setup

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