# Kalshi Weather Markets Scraper (`deriverge/kalshi-weather-markets-scraper`) Actor

Kalshi daily high and low temperature markets for 24 US cities, one row per bracket with bid, ask, probability, volume and open interest. Each city and day gets the market-implied temperature, and settled markets add the measured temperature for history.

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

## Pricing

from $0.40 / 1,000 markets

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?

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

## Kalshi Weather Markets Scraper

Kalshi Weather Markets Scraper returns Kalshi's daily high and low temperature markets, one row per bracket: the temperature range in °F, yes bid and ask, last price, implied probability, volume and open interest. Every city and day also gets the market's implied temperature and the most likely bracket, and settled markets carry the measured temperature. Leave **Cities** empty and click **Start** for all 24 cities; the 576 open brackets took 23 seconds on 11 October 2026. Rain, snow and other weather markets are not included. It costs $0.80 per 1,000 markets on the Free plan ($0.40 on Business), and the $5 of monthly credit in Apify's Free plan covers about 6,200 markets.

### What data does it return?

| Field | Description |
|---|---|
| `ticker`, `eventTicker`, `seriesTicker` | Kalshi tickers of the bracket (`KXHIGHNY-26OCT12-B71.5`), of the city and day (`KXHIGHNY-26OCT12`) and of the series (`KXHIGHNY`, the New York City daily high). |
| `city`, `measure`, `date` | City as Kalshi names it (`New York City`, `Washington DC`), `high` or `low`, and the day the temperature is measured, `YYYY-MM-DD`. |
| `bracket`, `lowF`, `highF`, `strikeType` | The bracket as Kalshi shows it (`71° to 72°`, `77° or above`), its lowest and highest whole degree Fahrenheit (`null` on the open side), and `between`, `greater` or `less`. |
| `yesBid`, `yesAsk`, `lastPrice` | Best bid and ask for Yes and the last trade, in dollars per contract that pays $1. |
| `probability` | The implied probability from 0 to 1: the bid and ask midpoint, the last price when there is no quote, and 1 or 0 once settled. |
| `volume`, `volume24h`, `openInterest` | Contracts traded in total and in the last 24 hours, and contracts held. Kalshi counts fractions of contracts, so `216.94` is possible. |
| `impliedTemperatureF` | The market's forecast for the city and day: bracket midpoints weighted by their probabilities, such as `71.2`. Open markets only. |
| `mostLikelyBracket` | The bracket with the highest probability for that city and day. |
| `probabilitySum` | Sum of the probabilities of all brackets of the day. Above 1 (`1.03`) the quotes carry a spread. |
| `status`, `result` | `open`, `closed` (trading over, waiting for the reading) or `settled`, and `yes` or `no` once settled. |
| `settledTemperatureF` | The measured temperature the market settled on, such as `69`. Settled markets only. |
| `closesAt`, `expectedSettlementAt` | When trading ends and when Kalshi expects to settle, ISO 8601 UTC. |
| `settlementSource`, `settlementSourceUrl` | Whose reading settles the series, `The Weather Company` in October 2026, and its link. |
| `url`, `key`, `scrapedAt` | The series page on kalshi.com, the row key `kalshi:<ticker>`, and when the row was read. |

### How to scrape Kalshi weather markets

1. Type **Cities** as Kalshi names them, such as `New York`, `Chicago`, `Miami` or `Los Angeles`, or leave the field empty for every city. Part of the name is enough, so `New York` finds Kalshi's `New York City`.
2. Pick high, low or both in **Daily high or low**.
3. In **Markets**, choose `open` for live prices of today and tomorrow, `settled` for history with measured temperatures, or `all`, which also returns yesterday's markets that wait for their reading.
4. For history, set **Date from** and **Date to** as `YYYY-MM-DD` or relative days (`-30`, `yesterday`). Settled markets without a start date cover about the last month.
5. Set **Maximum markets** high enough (2,000 by default) and click **Start**. The **Output** tab lists the brackets, newest day first, for export as CSV, Excel or JSON. `SUMMARY` in the key-value store gives the markets per series and any failed request.

An API input for a month of settled history in four cities:

```json
{
  "cities": ["New York", "Chicago", "Miami", "Austin"],
  "status": "settled",
  "dateFrom": "-30",
  "dateTo": "yesterday",
  "maxItems": 5000
}
```

### Example output

The most likely bracket of the New York City high for 12 October, read on 11 October 2026. The six brackets of that day added up to a probability of 1.03.

```json
{
  "key": "kalshi:KXHIGHNY-26OCT12-B71.5",
  "ticker": "KXHIGHNY-26OCT12-B71.5",
  "eventTicker": "KXHIGHNY-26OCT12",
  "seriesTicker": "KXHIGHNY",
  "city": "New York City",
  "measure": "high",
  "date": "2026-10-12",
  "bracket": "71° to 72°",
  "lowF": 71,
  "highF": 72,
  "strikeType": "between",
  "yesBid": 0.47,
  "yesAsk": 0.48,
  "lastPrice": 0.49,
  "probability": 0.475,
  "volume": 216.94,
  "volume24h": 216.94,
  "openInterest": 177.43,
  "status": "open",
  "result": null,
  "settledTemperatureF": null,
  "impliedTemperatureF": 71.2,
  "mostLikelyBracket": "71° to 72°",
  "probabilitySum": 1.03,
  "closesAt": "2026-10-13T05:00:00.000Z",
  "expectedSettlementAt": "2026-10-13T19:00:00.000Z",
  "settlementSource": "The Weather Company",
  "settlementSourceUrl": "https://weather.com/kalshi",
  "url": "https://kalshi.com/markets/kxhighny",
  "scrapedAt": "2026-10-11T16:37:54.566Z"
}
```

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

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 markets | $0.80 | $0.64 | $0.52 | $0.40 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

A snapshot of all open brackets, 576 on 11 October 2026, costs less than $0.48 on the Free plan. The settled history of all 24 cities from 11 September to 10 October 2026 held 8,628 brackets, less than $7.20 on the Free plan and $3.60 on Business. Series without markets in your range and requests that fail are not charged.

### Limits

- Kalshi lists 103 daily temperature series. In October 2026, 48 of them had markets: the high and the low for 24 US cities. The other series, including older tickers of the same cities, return nothing.
- Open markets cover today and tomorrow, with 6 brackets per city and day. A run with all cities makes about 150 requests to Kalshi.
- Settled history is read up to 10,000 brackets per series and run, which is more than four years of days.
- The actor reads market data only. It does not add weather forecasts or the code of the weather station, and probabilities are quoted as they are, without removing the spread.
- Every request waits at least 120 milliseconds after the previous one. A request that fails is tried 3 times, and a run fails when more than half of its requests do.

### Kalshi API and run reliability

The actor reads Kalshi's public trade API, the documented interface Kalshi offers for market data, without a key, a login or a browser. A run therefore depends only on Kalshi answering. All 23 runs of this actor from 27 September to 11 October 2026 finished successfully, the longest in 28 seconds. If Kalshi does not return its list of weather series, the run fails at once with a message and costs nothing.

### FAQ

#### Is it legal to scrape Kalshi?

The actor reads public market data from Kalshi's documented trade API, the same prices anyone sees on kalshi.com, without an account. Market data has no personal information. You are responsible for following Kalshi's terms in how you use it, especially for trading.

#### How is the implied temperature calculated?

For each city and day, the midpoint of every bracket is weighted by its probability, and open brackets count one degree beyond their limit: `77° or above` counts as 78. The result is divided by the sum of probabilities, so a spread in the quotes does not shift it.

#### Can I build a backtest from this?

Yes. Settled markets give the measured temperature and the winning bracket for each day, with the last price and volume. They do not show how the odds moved before the close, so to keep the market's forecast for each day, run the actor on a schedule while markets are open and store the rows.

### Related scrapers

- [Kalshi and Polymarket Scraper](https://apify.com/deriverge/kalshi-polymarket-scraper)
- [Sports Odds Scraper](https://apify.com/deriverge/sports-odds-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/kalshi-weather-markets-scraper/changelog.md

# Actor input Schema

## `cities` (type: `array`):

Cities as Kalshi names them, for example New York, Chicago, Miami, Austin, Denver, Los Angeles, Philadelphia, Houston, Seattle or Phoenix. Leave empty for every city.

## `measures` (type: `array`):

Markets on the daily high, the daily low, or both (leave empty).

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

Open markets for live odds, settled markets for history.

## `dateFrom` (type: `string`):

Earliest market day, as YYYY-MM-DD or relative: today, yesterday, -7, -30. For settled markets without a date, the last month is returned.

## `dateTo` (type: `string`):

Latest market day, as YYYY-MM-DD or relative: today, tomorrow, +1.

## `seriesTickers` (type: `array`):

Exact Kalshi series, for example KXHIGHNY or KXLOWTCHI, instead of or on top of the city filter.

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

Hard cap on returned bracket markets. Each city and day has about six brackets.

## Actor input object example

```json
{
  "cities": [
    "New York",
    "Chicago",
    "Miami",
    "Austin"
  ],
  "status": "open",
  "maxItems": 100
}
```

# Actor output Schema

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

One row per bracket with prices, probability, volume, implied temperature and settled temperature.

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

Series matched, markets returned per series and request counts.

# 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 = {
    "cities": [
        "New York",
        "Chicago",
        "Miami",
        "Austin"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/kalshi-weather-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 = {
    "cities": [
        "New York",
        "Chicago",
        "Miami",
        "Austin",
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("deriverge/kalshi-weather-markets-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 '{
  "cities": [
    "New York",
    "Chicago",
    "Miami",
    "Austin"
  ],
  "maxItems": 100
}' |
apify call deriverge/kalshi-weather-markets-scraper --silent --output-dataset

```

## MCP server setup

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