# Kalshi Weather Prediction Markets - Odds API (`dataio/kalshi-weather-markets`) Actor

Kalshi weather prediction markets data: every daily high and low temperature market, bracket by bracket, with odds, implied probability, volume and results. Joined with today's observed temperature at the NWS settlement station, and a signal when a bracket is already decided.

- **URL**: https://apify.com/dataio/kalshi-weather-markets.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** News, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 market brackets

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

### What does Kalshi Weather Prediction Markets do?

This actor extracts every Kalshi **weather prediction market**: the daily high
and low temperature markets (KXHIGH / KXLOW series), bracket by bracket, with
odds, implied probability, volume and results. It also **joins each market with
the temperature already observed today at the station that settles it**. You
get the odds, and you get what the thermometer has already decided.

- **All the series, found automatically.** The actor reads Kalshi's own list of
  weather series on every run. On 19 Sep 2026 that was 104 series, 48 of them
  open, 288 brackets across 24 cities. A new city appears without anyone
  editing a table.
- **The right station.** Each market's rules name its NWS climate station
  (`CLIMDW`), and the actor derives the observation station from it (`KMDW`):
  Chicago settles at Midway, not O'Hare. Measured: 24 stations out of 24
  resolved.
- **The right day.** The NWS climate day runs midnight to midnight in local
  **standard** time, and daylight saving is ignored. In summer it runs from
  1 am to 1 am on the clock, and observed highs and lows use exactly that
  window.
- **Brackets already decided.** A daily high only goes up and a daily low only
  goes down, so some brackets are settled before the day ends.
  `observationSignal` flags them, with a 1°F safety margin.
- **History for backtests.** Settled markets come with their result and the
  settlement temperature. Checked on 288 settled brackets: the result matches
  the settlement value and the bracket bounds every time.

### What data can you extract from Kalshi weather markets?

| Data | Fields |
|---|---|
| Market | `ticker`, `eventTicker`, `seriesTicker`, `city`, `measure`, `marketDate`, `bracket`, `strikeType`, `floorStrikeF`, `capStrikeF` |
| Odds | `yesBid`, `yesAsk`, `lastPrice`, `noBid`, `noAsk`, `impliedProbability` |
| Activity | `volume`, `volume24h`, `openInterest`, `liquidityDollars` |
| Settlement | `status`, `result`, `settlementValue`, `closeTime`, `settlementSource`, `rules` |
| Station | `climateStationId`, `stationIcao`, `stationName` |
| Today's observations | `observedHighF`, `observedLowF`, `observationCount`, `lastObservationAt`, `observationSignal` |

### How to get Kalshi weather market data

1. Leave **cities** empty for all of them, or name them as Kalshi does: `New York City`, `Chicago`, `Miami`.
2. Choose the **measure** (high, low or both) and the **markets**: live odds, settled history, or both.
3. Keep **station observations** on to see today's observed high and low next to each bracket.
4. Click **Start**. For live monitoring, schedule it every few minutes.

### How much does it cost?

One event per market bracket returned.

| Job | Rows | Cost |
|---|---|---|
| Two cities, high and low, live | 24 | about $0.02 |
| Every open weather market | ~288 | about $0.29 |
| 30 days of settled history, all cities | ~8,600 | about $8.60 |

Subscription plans pay less per row.

### Input example

```json
{ "cities": ["New York City", "Chicago", "Miami"], "measure": "high", "mode": "live" }
```

### Output example

```json
{
  "ticker": "KXHIGHAUS-26SEP19-T96",
  "city": "Austin",
  "measure": "high",
  "marketDate": "2026-09-19",
  "bracket": "95° or below",
  "strikeType": "less",
  "capStrikeF": 96,
  "yesBid": 0.04,
  "yesAsk": 0.05,
  "impliedProbability": 0.045,
  "volume24h": 1751.16,
  "stationIcao": "KAUS",
  "stationName": "Austin-Bergstrom International Airport",
  "observedHighF": 80.6,
  "observationSignal": ""
}
```

### How the "already decided" signal works

Kalshi's bracket meaning, checked on 288 brackets: `less` with cap C wins if
T ≤ C−1 ("95° or below" for C = 96). `between` a–b wins if a ≤ T ≤ b.
`greater` with floor X wins if T ≥ X+1 ("104° or above" for X = 103). T is the
whole-degree settlement temperature.

The 5-minute station data comes in whole degrees Celsius, which is ±1°F once
converted. The signal fires only when the observation clears the bracket edge
by that margin plus the half-degree of rounding. It is conservative on purpose:
on 19 Sep 2026 it flagged 12 brackets, and the market was already pricing every
one of them at 0–1¢.

### Use the Kalshi weather API in Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/kalshi-weather-markets").call(run_input={"measure": "high"})
for m in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(m["city"], m["bracket"], m["impliedProbability"], m["observedHighF"], m["observationSignal"])
```

Works from JavaScript, n8n, or trading agents through the Apify MCP server.

### Other actors you might like

- [Google Trends Scraper & API](https://apify.com/DataIO/google-trends-scraper): search interest for up to 100 keywords on one scale.
- [Google Hotels Scraper](https://apify.com/DataIO/google-hotels-scraper): hotel prices and ratings for any city and dates.
- [DefiLlama Protocol Revenue & TVL](https://apify.com/DataIO/defillama-protocol-revenue-tvl): on-chain market data.

### FAQ

#### Is the settlement temperature the same as the observed one?

Not always. Settlement uses The Weather Company's figure, as the market rules
say. Observations come from the NWS feed for the same station, and the two can
differ by a degree. The signal's margin covers the usual gap, but it is no
guarantee.

#### Which cities are covered?

Every city Kalshi lists, currently US cities. International series (Berlin,
London, Mexico City) sit in Kalshi's catalogue and are read if they open, but
no NWS observation is joined for them.

#### Is this trading advice?

No. It is market and weather data.

### Source

Kalshi public trade API (v2) and the National Weather Service API
(api.weather.gov). Both are public and need no key. This actor is not
affiliated with Kalshi or the NWS.

# Actor input Schema

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

Leave empty for every city Kalshi lists (48 daily high/low series were open on 19 Sep 2026). Or give names as Kalshi writes them: "New York City", "Chicago", "Miami", "Austin", or a series ticker such as KXHIGHNY.

## `measure` (type: `string`):

Daily maximum (KXHIGH series), daily minimum (KXLOW series), or both.

## `mode` (type: `string`):

Live markets with current odds, settled markets with their result and settlement temperature (for backtests), or both.

## `lookbackDays` (type: `integer`):

How many days of settled markets to return.

## `includeObservations` (type: `boolean`):

For live markets: the highest and lowest temperature observed so far today at the settlement station (NWS, 5-minute data), over the NWS climate day, which runs midnight to midnight local STANDARD time. Adds observationSignal when a bracket is already decided.

## `onlyWithSignal` (type: `boolean`):

Return only the brackets that today's observations already decide (with a 1°F safety margin).

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

One row per bracket market.

## Actor input object example

```json
{
  "cities": [
    "New York City",
    "Chicago"
  ],
  "measure": "both",
  "mode": "live",
  "lookbackDays": 7,
  "includeObservations": true,
  "onlyWithSignal": false,
  "maxItems": 200
}
```

# Actor output Schema

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

Every row produced by the run, in JSON.

# 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 City",
        "Chicago"
    ],
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/kalshi-weather-markets").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 City",
        "Chicago",
    ],
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/kalshi-weather-markets").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 City",
    "Chicago"
  ],
  "maxItems": 200
}' |
apify call dataio/kalshi-weather-markets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataio/kalshi-weather-markets"
        }
    }
}
```

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/VNzZaO3b7s0dJOeLF/builds/z32j7rkMvhDU1LBVa/openapi.json