# Kalshi Weather Markets — Prices & Settled Temps (`diopside/kalshi-weather-markets`) Actor

Every Kalshi KXHIGH/KXLOW daily temperature market: live bid/ask, open interest, settled temperatures, trades and orderbooks. Auto-discovers all 100+ series (US + London, Paris, Tokyo, Toronto, Sydney...). Official public API, no login.

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

## Pricing

from $1.00 / 1,000 market records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — live prices & settled temperatures

Pull every Kalshi **daily high / daily low temperature market** (KXHIGH\*, KXLOW\*) as clean JSON:
per-bracket bid/ask, last price, volume, open interest, and — for settled markets — the **official
settlement temperature**. Optionally attach recent trades and the full orderbook.

- **Auto-discovers every series Kalshi lists** (100+ today: 20+ US cities plus London, Paris, Tokyo,
  Toronto, Sydney, Dubai, Mexico City…). New cities show up without an actor update.
- **Reads Kalshi's official public market-data API** — no login, no API key, no scraping of HTML,
  nothing to break when the website changes.
- **Built for reliability**: rate-limited, retried with backoff, partial failures never kill the run.
- **Correct settlement stations**: Chicago = Midway (KMDW), Dallas = DFW, Houston = Hobby (KHOU),
  NYC = Central Park (KNYC). Getting these wrong costs real money.

### vs other Kalshi scrapers

The other Kalshi actors in the store (`kalshi-prediction-markets-tracker`,
`kalshi-prediction-market-scraper`, `kalshi-scraper` — 24–29 monthly users each) are general
market trackers: sports, elections, economics, weather all mixed together, with no series
discovery and no settlement-station mapping. None is built specifically for the 100+
KXHIGH/KXLOW weather markets, so none guards against the Chicago-is-Midway-not-O'Hare class of
error this actor is built around.

### Input

| field | default | notes |
|---|---|---|
| `cities` | `["NYC"]` | Names, aliases or ICAO codes: `NYC`, `Chicago`, `London`, `KLAX`, `EGLL`… or `["all"]` |
| `seriesType` | `both` | `KXHIGH` (daily highs), `KXLOW` (daily lows), `both` |
| `mode` | `live` | `live` = tradeable now, `settled` = finalized with settlement temp, `both` |
| `lookbackDays` | `30` | settled-history window, 1–365 |
| `includeTrades` | `false` | up to 1,000 recent fills per market (+1 call per market) |
| `includeOrderbook` | `false` | current YES/NO bid levels (+1 call per market) |
| `maxRecords` | `0` | stop after N records (0 = unlimited) |

### Output — one record per market

```json
{
  "ticker": "KXHIGHNY-26SEP16-B81.5",
  "event_ticker": "KXHIGHNY-26SEP16",
  "city": "New York",
  "station_id": "KNYC",
  "series_ticker": "KXHIGHNY",
  "series_type": "KXHIGH",
  "title": "Will the maximum temperature be 81-82° on Sep 16, 2026?",
  "bracket_label": "81° to 82°",
  "strike_type": "between",
  "floor_strike": 81,
  "cap_strike": 82,
  "status": "finalized",
  "result": "no",
  "settlement_temp_f": 77.0,
  "settlement_time": "2026-09-17T12:01:51Z",
  "open_time": "2026-09-15T14:00:00Z",
  "close_time": "2026-09-17T05:00:00Z",
  "yes_bid": 0.0, "yes_ask": 1.0, "no_bid": 0.0, "no_ask": 1.0,
  "last_price": 0.01, "previous_price": 0.02,
  "volume": 4537.22, "volume_24h": 120.0, "open_interest": 4163.05, "liquidity": 0.0,
  "scraped_at": "2026-09-18T08:50:02Z"
}
```

Prices are USD per contract (0.00–1.00). Quantities can be fractional. `result` and
`settlement_temp_f` are `null` while a market is live. When `includeTrades` / `includeOrderbook`
are on, records carry `trades: [{trade_id, created_time, yes_price, no_price, count, taker_side}]`
and `orderbook: {yes_dollars: [[price, size], …], no_dollars: [[price, size], …]}`; the keys are
absent when the flags are off, and `null` if that one fetch failed.

### Typical sizes

- Live, one city, both series: ~12 records.
- Settled, one city, 30 days: ~350 records. All US cities, 90 days: ~20,000.
- Kalshi lists many international series that only run part of the year; those are reported as
  "no markets right now" rather than as errors.

### Use cases

Backtesting weather-market strategies, calibrating forecasts against settlement temperatures,
monitoring bracket prices vs. NWS/METAR observations, feeding dashboards and AI agents.

### Pricing

Pay per market record. No subscription, no minimum. See the pricing tab.

### Notes

Market data only — this actor never logs in, never places orders, and holds no credentials.
Kalshi's API is the source of truth; if a field disappears upstream, the corresponding output
field is `null` rather than the run failing.

# Actor input Schema

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

City names, aliases or ICAO station codes — e.g. NYC, Chicago, London, Tokyo, Toronto, KLAX, EGLL. Use \["all"] for every city Kalshi lists (100+ series). Matching is case-insensitive and fuzzy.

## `seriesType` (type: `string`):

Daily high markets (KXHIGH), daily low markets (KXLOW), or both.

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

live = tradeable markets with current prices; settled = finalized markets with the official settlement temperature; both.

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

How far back to fetch settled markets. Only used when mode includes settled.

## `includeTrades` (type: `boolean`):

Attach up to 1,000 most recent fills per market (one extra API call per market).

## `includeOrderbook` (type: `boolean`):

Attach current bid levels for YES and NO (one extra API call per market). Empty for settled markets.

## `maxRecords` (type: `integer`):

Stop after this many market records (0 = no limit).

## Actor input object example

```json
{
  "cities": [
    "NYC",
    "Chicago",
    "London"
  ],
  "seriesType": "both",
  "mode": "live",
  "lookbackDays": 30,
  "includeTrades": false,
  "includeOrderbook": false,
  "maxRecords": 0
}
```

# Actor output Schema

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

All market records as JSON. Append ?format=csv for CSV.

## `datasetUrl` (type: `string`):

The default dataset containing the market records.

# 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": [
        "NYC",
        "Chicago",
        "London"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("diopside/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": [
        "NYC",
        "Chicago",
        "London",
    ] }

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

```

## MCP server setup

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