# Kalshi Weather Markets + Station Nowcast (`nanare-sudo/kalshi-weather-markets`) Actor

Live Kalshi weather & temperature market data (KXHIGH, KXLOWT, rain, snow, hurricanes) with orderbooks, candlestick history, settled results and NWS/METAR station observations joined as distance-to-strike. Rebuilt for Kalshi's August 2026 API (dollars/fp fields).

- **URL**: https://apify.com/nanare-sudo/kalshi-weather-markets.md
- **Developed by:** [Leonardo Berisha](https://apify.com/nanare-sudo) (community)
- **Categories:** Agents, Developer tools, Other
- **Stats:** 8 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 market snapshots

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?

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 Weather Markets + Station Nowcast

Get live **Kalshi weather market data** — temperature markets (KXHIGH, KXLOWT), rain, snow and hurricane series — as clean JSON, joined with the **latest NWS/METAR station observation** and a computed **distance to strike**. Built for weather-market traders, quant researchers and AI agents.

**Rebuilt in August 2026 for Kalshi's new API.** Kalshi removed the legacy integer price fields (`last_price`, `yes_bid` …) and replaced them with `*_dollars` / `*_fp` strings, renamed ticker families (KXLOW → KXLOWT) and moved settlement of daily temperature markets to **The Weather Company** (effective 2026-08-14). Actors that were not migrated fail on most runs. This actor parses **both field generations**, discovers series at runtime instead of hardcoding city tickers, and runs a public **daily canary self-test** against every endpoint it uses.

### What is Kalshi Weather Markets + Station Nowcast?

Kalshi runs 350+ Climate & Weather series — daily high/low temperature markets for NYC, Chicago, Denver, Phoenix, Philadelphia, Miami, Austin, plus international stations (London EGLL, Berlin, Hong Kong VHHH, Shanghai, Mexico City), rain, snow, and hurricane markets. This actor gives you, without any API key:

- **Market snapshots** — normalized prices (`yes_bid`, `yes_ask`, `last_price` in dollars), volume, open interest, strike type and strike, close/expiration times
- **Station nowcast join** — the current METAR/NWS temperature at the settlement station, 3-hour trend, and `distance_to_strike_f` (current °F minus strike) per market
- **Orderbooks** — full bid/ask depth per market
- **Candlestick history** — 1-minute, hourly or daily OHLC for any market
- **Settled markets** — results for backtesting weather trading models
- **Series discovery** (free) — every active weather series incl. settlement sources
- **Canary self-test** (free) — verify all endpoints are healthy before you rely on them

### Live example (2026-08-19, NYC + Chicago daily highs)

One run, `mode: "markets"`, 12 open markets — each record joins the market with the current
observation at its settlement station:

| Market | Last | Strike | Station | Station °F | 3h trend | Distance to strike |
|---|---|---|---|---|---|---|
| KXHIGHNY-26AUG19-T92 | $0.01 | >92 | KNYC | 73.9 | — | **−18.1 °F** |
| KXHIGHNY-26AUG19-T85 | $0.11 | ≤85 | KNYC | 73.9 | — | −11.1 °F |
| KXHIGHCHI-26AUG19-B80.5 | $0.35 | 80–81 | KMDW | 68.0 | −1.1 | −12.0 °F |

`distance_to_strike_f` is the field no other Kalshi actor produces: current station temperature
minus the market's strike, computed per market. Sample CSV and a Python example:
[github.com/nanare-sudo/kalshi-polymarket-spreads](https://github.com/nanare-sudo/kalshi-polymarket-spreads)

### Input

```json
{
    "mode": "markets",
    "seriesTickers": ["KXHIGHNY", "KXHIGHCHI"],
    "includeNowcast": true,
    "includeOrderbooks": false,
    "maxMarkets": 200
}
```

Leave `seriesTickers` empty to auto-discover **all** active weather series. Filter with `cityFilter` (e.g. `"NYC"`, `"rain"`, `"London"`).

### Output

```json
{
    "type": "market",
    "series_ticker": "KXHIGHNY",
    "ticker": "KXHIGHNY-26AUG19-T92",
    "title": "Will the maximum temperature be >92° on Aug 19, 2026?",
    "status": "active",
    "strike_type": "greater",
    "floor_strike": 92,
    "yes_bid": 0.03,
    "yes_ask": 0.05,
    "last_price": 0.03,
    "volume_24h": 10342,
    "open_interest": 874,
    "close_time": "2026-08-20T05:00:00Z",
    "station": "KNYC",
    "nowcast": {
        "station": "KNYC",
        "temp_f": 88.9,
        "temp_trend_3h_f": 2.1,
        "observed_at": "2026-08-19T14:51:00Z",
        "raw_source": "nws-observation"
    },
    "distance_to_strike_f": -3.1,
    "settlement_note": "Kalshi daily temperature markets settle on The Weather Company data since 2026-08-14 …"
}
```

### Pricing

Pay per event — you only pay for data you actually receive:

| Event | Price |
|---|---|
| Actor start | $0.005 |
| Market snapshot (incl. nowcast join) | $0.004 |
| Orderbook snapshot | $0.002 |
| Settled market record | $0.002 |
| Station observation | $0.0008 |
| Candlestick batch (100 candles) | $0.01 |

`discover` and `canary` modes are free (only the start fee). A typical snapshot of all open NYC + Chicago temperature markets costs a few cents.

### Use with AI agents (MCP)

Every mode works through the [Apify MCP server](https://mcp.apify.com) — point your agent (Claude, ChatGPT, LangGraph, CrewAI …) at Apify and it can call this actor directly, e.g. *"fetch today's Kalshi high-temperature markets for NYC with the current Central Park observation"*. The input schema is designed to be agent-friendly: one `mode` switch, sensible defaults, no API keys.

### FAQ

**Is this legal?** The actor only reads Kalshi's public, unauthenticated market-data API (which Kalshi documents for exactly this purpose) and U.S. government weather data (public domain). No login, no paywall, no personal data.

**Does it use the new or the old Kalshi API fields?** Both. The parser accepts the new `*_dollars`/`*_fp` string fields and falls back to the legacy integer-cent fields, so records stay stable even if Kalshi migrates again.

**Which station settles my market?** Since 2026-08-14 Kalshi settles daily temperature markets on The Weather Company data (see weather.com/kalshi). The nowcast in this actor uses the corresponding NWS/METAR station as a real-time indicator — the record carries the official `settlement_sources` from the Kalshi API plus a `settlement_note`.

**Can I backtest?** Yes — `mode: "settled"` returns markets with results (`yes`/`no`) for the last N days, and `mode: "candlesticks"` returns full price history.

**What about rate limits?** The actor batches requests, respects Kalshi's public rate limits and retries with backoff across both Kalshi API hosts.

### Keywords

kalshi weather markets, kalshi api without key, kalshi temperature market data, KXHIGH, KXHIGHNY, KXHIGHCHI, KXLOWT, kalshi orderbook api, kalshi candlesticks, kalshi settlement weather company, NWS station observations, METAR temperature api, prediction market weather data, weather trading bot data, kalshi backtesting settled markets, distance to strike

# Actor input Schema

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

What to fetch: `markets` = open weather markets (optionally joined with live station observations), `settled` = settled markets with results (for backtesting), `orderbooks` = full orderbooks for open markets, `candlesticks` = price history, `observations` = raw METAR/NWS station observations only, `discover` = list all Kalshi weather series (free), `canary` = health self-test of all endpoints (free).

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

Kalshi series tickers to fetch, e.g. `KXHIGHNY`, `KXHIGHCHI`, `KXLOWTPHX`. Leave empty to auto-discover every active Climate & Weather series (recommended — Kalshi renames tickers, hardcoding breaks).

## `cityFilter` (type: `string`):

Case-insensitive substring filter on the series title, e.g. `NYC`, `Chicago`, `London`, `rain`. Applied after discovery.

## `includeNowcast` (type: `boolean`):

For temperature markets: join the latest METAR/NWS observation of the settlement station and compute `distance_to_strike` (current °F minus market strike). One extra charged observation per station, not per market.

## `includeOrderbooks` (type: `boolean`):

In `markets` mode additionally fetch the full orderbook for each market (charged per orderbook).

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

Hard cap on the number of markets processed in one run.

## `candlestickPeriodMinutes` (type: `integer`):

Candlestick interval for `candlesticks` mode. Allowed by Kalshi: 1, 60 or 1440 minutes — other values are snapped to the nearest allowed one.

## `candlestickHoursBack` (type: `integer`):

How many hours of history to fetch per market in `candlesticks` mode.

## `settledDaysBack` (type: `integer`):

In `settled` mode: fetch markets that closed within the last N days.

## `stationIds` (type: `array`):

ICAO/NWS station IDs for `observations` mode, e.g. `KNYC`, `KMDW`, `EGLL`. Ignored in other modes.

## `stationOverrides` (type: `object`):

Optional map of series ticker → station ID to override the built-in station inference, e.g. `{"KXHIGHNY": "KNYC"}`.

## Actor input object example

```json
{
  "mode": "markets",
  "seriesTickers": [
    "KXHIGHNY",
    "KXHIGHCHI"
  ],
  "includeNowcast": true,
  "includeOrderbooks": false,
  "maxMarkets": 200,
  "candlestickPeriodMinutes": 60,
  "candlestickHoursBack": 24,
  "settledDaysBack": 7,
  "stationIds": [],
  "stationOverrides": {}
}
```

# Actor output Schema

## `records` (type: `string`):

All result records (type field: market | orderbook | settled\_market | candlesticks | observation | series | canary) as JSON array.

# 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 = {
    "seriesTickers": [
        "KXHIGHNY",
        "KXHIGHCHI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nanare-sudo/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 = { "seriesTickers": [
        "KXHIGHNY",
        "KXHIGHCHI",
    ] }

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

```

## MCP server setup

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