# Kalshi Weather Markets - Temperature & Rain Odds (`mambo_melon/kalshi-weather-markets`) Actor

Every Kalshi weather market as one row: daily high/low temperature and rain brackets for all cities, hourly temperature, monthly rain, hurricanes. Live odds and settled results, with the settlement station's forecast and today's observed high/low next to each bracket.

- **URL**: https://apify.com/mambo\_melon/kalshi-weather-markets.md
- **Developed by:** [Joran Morgan](https://apify.com/mambo_melon) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 market rows

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 - Temperature & Rain Odds

Every Kalshi weather market as a flat table: daily high and low temperature brackets for every city Kalshi lists, daily "will it rain" markets, monthly rain totals, hourly temperature, monthly averages, snow, hurricanes and the rest of the Climate and Weather category. Live odds or settled results.

For daily temperature and rain markets it also pulls what I always end up checking by hand before a trade: the forecast for the settlement station on that day, the high or low observed at that station so far today, and whether each of those lands inside the bracket. So you can see at a glance where the market and the forecast disagree.

It reads Kalshi's public market-data API directly, no login or API key. Series are discovered automatically, so when Kalshi adds a new city or a new kind of weather market it shows up without an update.

### Example

Input:

```json
{ "marketTypes": ["daily_high"], "cities": ["Chicago"], "mode": "live" }
```

One of the six brackets that came back (real output, Sep 29 2026, morning run):

```json
{
  "ticker": "KXHIGHCHI-26SEP29-B76.5",
  "marketType": "daily_high",
  "city": "Chicago",
  "station": "MDW",
  "stationIcao": "KMDW",
  "date": "2026-09-29",
  "bracket": "76° to 77°",
  "strikeType": "between",
  "floorStrike": 76,
  "capStrike": 77,
  "status": "active",
  "yesBid": 0.43,
  "yesAsk": 0.44,
  "lastPrice": 0.44,
  "impliedProbability": 0.435,
  "spread": 0.01,
  "volume": 3264.03,
  "volume24h": 3216.07,
  "openInterest": 2747.73,
  "forecastF": 76,
  "forecastInBracket": true,
  "observedTodayF": 62.6,
  "observedTodayInBracket": false,
  "observedTodayAt": "2026-09-29T12:40:00+00:00",
  "closeTime": "2026-09-30T06:00:00Z",
  "settlementSource": "The Weather Company",
  "marketUrl": "https://kalshi.com/markets/kxhighchi/kxhighchi-26sep29",
  "rules": "If the maximum temperature recorded at Chicago (CLIMDW) for Sep 29, 2026, is between 76-77° fahrenheit according to The Weather Company, then the market resolves to Yes."
}
```

The whole event from that run. The forecast points at 76-77°, the market leans slightly to 78-79°:

| Bracket | Market | NWS forecast 76°F in it? |
|---|---|---|
| 73° or below | 2.5% | no |
| 74° to 75° | 9.5% | no |
| 76° to 77° | 43.5% | yes |
| 78° to 79° | 47.5% | no |
| 80° to 81° | 1.5% | no |
| 82° or above | 0.5% | no |

Rain markets from the same morning: Phoenix "will it rain" traded at 99.5% with a 98% NWS chance of rain, Seattle at 89% with 76%.

Settled mode gives you the history with results, for example `"bracket": "68° to 69°", "result": "yes", "settlementValue": 68` for Chicago on Sep 26.

### Fields worth knowing

- `impliedProbability` is the bid/ask midpoint when the book is reasonably tight (spread up to 25 cents). On a wide book it falls back to the last trade, and it's `null` if the market never traded, rather than pretending a 0.05/0.96 book means 50%.
- `forecastF` is the National Weather Service forecast high (or low, for low markets) at the settlement station's grid point for the market's local date. `forecastPrecipChance` (%) and `forecastPrecipIn` do the same for daily rain markets.
- `observedTodayF` is the highest (or lowest) temperature reported by the station since local midnight, from the National Weather Service's observations API. It's only filled for today's markets.
- `station` is the climate site named in the market rules (`CLIMDW` → `MDW`, ICAO `KMDW`).
- The forecast and observations are context, not the settlement. Each market settles on the source in its `rules`.

Every row has the same fields; anything that doesn't apply is `null`.

### Input

| Field | What it does | Default |
|---|---|---|
| `marketTypes` | `daily_high`, `daily_low`, `rain_daily`, `rain_monthly`, `hourly_temp`, `monthly_avg_temp`, `snow`, `hurricane`, `other`, or `all` | temperature + rain |
| `cities` | Only series whose name contains one of these words (`Chicago`, `NYC`, `Miami`...). Empty = all | empty |
| `mode` | `live` (open markets) or `settled` (closed within the lookback) | `live` |
| `lookbackDays` | How far back settled mode goes | 7 |
| `includeStationContext` | Add forecast and today's observations | on |
| `minVolume24h` | Skip thin markets | 0 |
| `maxItems` | Cap on rows | 5000 |

A live run over every weather market (about 1,100 rows) takes around a minute and a half. A single city takes a few seconds.

### How people use it

Scheduling it every 15 or 30 minutes into Google Sheets or a database to track how brackets move during the day; comparing the market against the forecast to find mispriced brackets; building a settled-results history to backtest a model; or giving an AI agent live weather odds through the Apify MCP server.

### FAQ

**Is this official Kalshi data?**
It comes from Kalshi's public API, the same prices you see on kalshi.com. This Actor isn't affiliated with Kalshi.

**Why is `observedTodayF` lower than the forecast in the morning?**
Because it's the high so far. It climbs through the day; the market settles on the full day's value.

**Some markets have no city or station.**
Hurricanes, earthquakes, sea ice and similar markets aren't tied to one weather station, so those fields are `null`.

**What does a run cost?**
See the Pricing tab: a small fee per run plus a fee per market row. Filter by `cities`, `marketTypes` or `minVolume24h` to pay only for what you need.

### Notes

Forecasts and observations: [National Weather Service API](https://www.weather.gov/documentation/services-web-api) (public domain). Market data: Kalshi public API. Station context is available for US stations, which is where all of Kalshi's daily temperature and rain markets are today.

Something off in a market or a station mapping? Open an issue with the ticker and I'll fix it.

# Actor input Schema

## `marketTypes` (type: `array`):

Which kinds of weather markets to return. 'all' includes hurricanes, snow and anything new Kalshi lists.

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

Only markets whose series name contains one of these words, e.g. 'Chicago', 'NYC', 'Miami'. Leave empty for all cities.

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

'live' = markets open for trading now. 'settled' = markets that closed within the lookback window, with results.

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

How far back to fetch settled markets.

## `includeStationContext` (type: `boolean`):

For live daily temperature and rain markets, add the forecast for the settlement station and day, today's observed high/low so far, and whether each value falls inside the bracket.

## `minVolume24h` (type: `integer`):

Skip markets that traded fewer contracts than this in the last 24 hours. 0 returns all.

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

Maximum number of market rows to return.

## Actor input object example

```json
{
  "marketTypes": [
    "daily_high",
    "daily_low",
    "rain_daily",
    "rain_monthly"
  ],
  "cities": [
    "Chicago",
    "NYC"
  ],
  "mode": "live",
  "lookbackDays": 7,
  "includeStationContext": true,
  "minVolume24h": 0,
  "maxItems": 5000
}
```

# Actor output Schema

## `odds` (type: `string`):

No description

## `settled` (type: `string`):

No description

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

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

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

```

## MCP server setup

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