# Kalshi Weather Markets with NWS Forecast & Settlement (`scrapebench/kalshi-weather-markets-nws-forecast-scraper`) Actor

Every Kalshi temperature and rain bracket with its price, the National Weather Service forecast for that city and day, whether the forecast lands in the bracket, and the reading that settled it.

- **URL**: https://apify.com/scrapebench/kalshi-weather-markets-nws-forecast-scraper.md
- **Developed by:** [ScrapeBench](https://apify.com/scrapebench) (community)
- **Categories:** News
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0012 / weather market

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 with NWS Forecast & Settlement

### Pain points

- A Kalshi temperature market's question never names the station or the forecast. The bracket is 'between 54-55', and whether that is likely lives in a different system, the National Weather Service's gridpoint forecast, which is in degrees Celsius and in windows of 13 hours.
- Kalshi opens a fresh event for every city and every day, and files weather under 126 daily series with overlapping names: high temperature in New York is KXHIGHNY, low temperature is KXLOWNY, KXLOWNYC and KXLOWTNYC (checked 2026-11-16). Finding the right ticker is half the work.
- Kalshi settles different series on different sources: most daily temperature series name The Weather Company, some name an NWS climatological report. The source differs by series and is stated on the series, not on the market.
- A bracket's price tells you what the market thinks of that band, not what the market thinks the day will reach. Turning twelve brackets into one expected temperature is arithmetic nobody wants to redo for each city.
- Kalshi's price fields are decimal strings with the suffixes \_dollars and \_fp, and a settled market keeps its reading in expiration_value, a string that is empty until the market settles.

### What we solve

- Finds the daily high, low and rain series for the cities you name, so you never look up a ticker.
- Puts the NWS forecast on every bracket: forecast high or low in Fahrenheit, inside the bracket or not, and the distance in degrees.
- Adds a market-implied temperature per event, the bracket midpoints weighted by price, next to the forecast.
- Reads today's high or low so far from the station's hourly observations.
- Returns settled markets with the reading that settled them and the source Kalshi names.
- Order book and recent trades per bracket as optional rows, each priced on its own.

### Summary

Reads Kalshi's daily weather markets, one row per bracket, and puts the National Weather Service forecast for that city and day next to the price: the forecast high or low, whether it falls inside the bracket, how many degrees outside it is, the chance of rain, and what the whole event's prices imply the temperature will be. Today's readings so far come from the station's hourly observations. Settled markets carry the reading that settled them and the source Kalshi names. The order book and the recent trades of each bracket are optional extra rows. Kalshi and api.weather.gov are public, keyless APIs: no login, no key, no browser. US cities get the NWS forecast; London, Tokyo, Paris and the other non-US cities Kalshi lists come back with prices and settlement only.

### Who it's for

- Weather traders comparing a bracket's price with the National Weather Service forecast
- Quant researchers backtesting forecast-versus-market on settled days
- Energy and commodity desks watching what the market expects the high to be
- Developers feeding a trading bot or a dashboard with one clean weather table

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "cities": [
    "NYC"
  ],
  "metrics": [
    "high",
    "low"
  ],
  "includeForecast": true,
  "maxResults": 60
}
```

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `ticker / event_ticker / series` | The Kalshi bracket, its city-and-day event and its daily series |
| `city / station / target_date / metric` | City, the station Kalshi's rules name, the day the market is about, and high, low or rain |
| `bracket_label / bracket_type / bracket_low / bracket_high` | The band and whether it is greater, less or between |
| `yes_bid / yes_ask / no_bid / no_ask / last_price / spread` | Top of book and the last trade, 0-1 |
| `implied_probability / price_change_24h` | Last trade (else the mid of the book), and the move from 24 hours ago |
| `volume / volume_24h / open_interest` | Contracts traded, traded in 24 hours, and outstanding |
| `nws_forecast_temp_f / nws_forecast_in_bracket / nws_distance_to_bracket_f` | The NWS forecast high or low for that day, whether it falls inside the bracket, and degrees outside (0 inside) |
| `nws_precip_probability_pct / nws_precip_in` | Highest NWS chance of precipitation that day and the expected inches |
| `nws_observed_so_far_f` | Today only: the station's high so far (high markets) or low so far (low markets) |
| `market_expected_temp_f` | What the event's prices imply, bracket midpoints weighted by price |
| `result / settlement_value / settlement_unit / settlement_source` | Yes or no, the reading that settled the market (F, or inches of rain) and who publishes it |
| `nws_forecast_status` | ok, not_us_city, outside_window (NWS reaches about a week), unavailable or not_requested |
| `row_type` | market, orderbook (yes and no ladders and depth) or trade-history (recent trades) |
| `rules / market_url / source_url` | Kalshi's resolution rule, the series page, and the endpoint the row came from |

Sample:

```json
{
  "source_url": "https://api.elections.kalshi.com/trade-api/v2/markets/KXHIGHNY-26NOV16-B54.5",
  "row_type": "market",
  "ticker": "KXHIGHNY-26NOV16-B54.5",
  "event_ticker": "KXHIGHNY-26NOV16",
  "series": "KXHIGHNY",
  "metric": "high",
  "city": "New York City",
  "station": "CLINYC",
  "target_date": "2026-11-16",
  "bracket_label": "54\u00b0 to 55\u00b0",
  "bracket_type": "between",
  "bracket_low": 54.0,
  "bracket_high": 55.0,
  "status": "active",
  "settlement_source": "The Weather Company",
  "yes_bid": 0.33,
  "yes_ask": 0.35,
  "no_bid": 0.65,
  "no_ask": 0.67,
  "last_price": 0.34,
  "implied_probability": 0.34,
  "spread": 0.02,
  "volume": 6014.74,
  "volume_24h": 6014.66,
  "open_interest": 4675.14,
  "open_time": "2026-11-15T15:00:00Z",
  "close_time": "2026-11-17T06:00:00Z",
  "market_expected_temp_f": 54.7,
  "nws_station": "KNYC",
  "nws_forecast_temp_f": 55.0,
  "nws_forecast_in_bracket": true,
  "nws_distance_to_bracket_f": 0.0,
  "nws_precip_probability_pct": 1,
  "nws_precip_in": 0.0,
  "nws_forecast_status": "ok",
  "market_url": "https://kalshi.com/markets/kxhighny"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `cities` | no | array | `["NYC"]` | Cities to read, as Kalshi names them: 'NYC', 'Chicago', 'Los Angeles', 'Miami', 'Denver', 'Austin'. Leave empty for every city. US cities get an NWS forecast; London, Tokyo, Paris and the rest are returned without one. |
| `city` | no | string | — | One city. Kept alongside 'Cities' for saved tasks and API callers. |
| `metrics` | no | array | `["high", "low"]` | high = daily high temperature, low = daily low temperature, rain = daily rain. Default: high and low. |
| `status` | no | string | `"open"` | open = markets still trading, with prices and forecast. settled = finished markets with the temperature that settled them. |
| `seriesTickers` | no | array | `[]` | Skip the city filter and name series directly: KXHIGHNY, KXLOWTEGLL (London low), KXRAINDNYC. Overrides 'Cities' and 'Markets to read'. |
| `days` | no | integer | `0` | Only markets for today and the next N-1 days. 0 = every open day. |
| `minVolume` | no | integer | `0` | Drop brackets with fewer contracts traded than this. Far-out brackets often sit at a cent with no trades. |
| `dates` | no | array | `[]` | Only markets for these days (YYYY-MM-DD). Empty = every open day, or the last few days when settled. |
| `lookbackDays` | no | integer | `3` | For 'settled': how many days back to read. |
| `includeForecast` | no | boolean | `true` | Adds the National Weather Service forecast for each bracket's city and day, whether it falls inside the bracket and how far outside. US cities, about a week ahead. |
| `includeOrderbook` | no | boolean | `false` | One extra row per market with every resting yes and no price level and the depth. Billed per row. |
| `includeTrades` | no | boolean | `false` | One extra row per market with its most recent trades (time, price, size, taker side). Billed per row. |
| `maxTrades` | no | integer | `50` | How many recent trades to list per market when trade history is on. |
| `maxResults` | no | integer | `100` | Cap on market rows for the whole run: your spend control. Nearest day first, busiest brackets first. Order book and trade rows follow the markets returned. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional and off by default: Kalshi and the National Weather Service are public, keyless APIs. |

### Pricing (Pay Per Event)

You pay per result (`market`) — **no charge for empty runs**. Example: **60 weather markets** at *$0.0012/result* ≈ **$0.072**.

$0.0012 per bracket, no start fee; 'Maximum markets' caps the run and its default is 100. The example input returned 60 NYC brackets on 2026-11-16, about $0.07. Order book and trade history are separate rows at $0.001 each, off by default.

### Use cases

- Find mispriced brackets: every open NYC high bracket with the NWS forecast, whether it lands inside, and the distance. City NYC, metric high.
- Track what the market expects: market_expected_temp_f next to nws_forecast_temp_f for every city, refreshed on a schedule. Leave cities empty, days 2.
- Intraday: today's high so far (nws_observed_so_far_f) against the brackets that are still alive. City Chicago, days 1.
- Backtest: the last two weeks of settled Chicago and Miami highs with the settled reading and the final price. Status settled, lookbackDays 14.
- Depth check before sizing a trade: turn on the order book for the three busiest brackets. includeOrderbook, maxResults 3.
- Rain: daily rain markets for New York or Seattle with the NWS chance of precipitation. Metric rain.

### Why this actor

- One row per bracket with price, volume, 24h change, forecast, bracket fit and settled reading in the same table.
- NWS forecast for 30 US cities with the station named, in Fahrenheit, as the day's high, low and chance of rain.
- Today's observed high or low so far, and the market-implied temperature, which the forecast alone cannot give you.
- Settled days with the reading, for backtests without joining a second source.
- A forecast that did not answer is said so on the row (nws_forecast_status) and in a free notice; prices are never held back.
- $0.0012 a bracket, no start fee; order book and trades only when you turn them on.

### Limitations & updates

Daily temperature and rain series only (high, low, rain); Kalshi's snow, hurricane and climate series are not read. NWS forecasts cover US cities about a week ahead; the city table covers the 30 US cities Kalshi lists daily markets for on 2026-11-16. The forecast point is the city's airport or park station, which may differ from the station Kalshi's settlement source uses. Prices are Kalshi's own; the forecast and market-implied temperature are shown, not recommendations. Public market data only and not investment advice.

### FAQ

**Where does the forecast come from?**

The National Weather Service's public API (api.weather.gov). For each city the actor reads the NWS gridpoint at the city's airport or park station, takes the forecast high or low for the bracket's calendar day in the city's own time zone, and converts it to Fahrenheit. The rain chance is the highest NWS probability of precipitation among that day's windows.

**Which cities get a forecast?**

The 30 US cities Kalshi lists daily markets for, including New York, Chicago, Miami, Los Angeles, Denver, Austin, Houston, Seattle and Washington DC. Non-US cities such as London, Tokyo and Paris come back with prices and settlement and nws_forecast_status 'not_us_city', because the National Weather Service forecasts only the United States.

**How far ahead does the forecast go?**

About a week: the NWS gridpoint covers roughly seven days. A bracket for a later day carries prices and nws_forecast_status 'outside_window'.

**What is market_expected_temp_f?**

The temperature the event's own prices imply. Each bracket's midpoint is weighted by its price and the weights are normalised; the open-ended bracket at each end counts 1.5 degrees beyond its strike. It is an approximation of what the market expects, and it is the same on every bracket of an event.

**How is the settled reading found?**

Kalshi publishes it on the market itself (expiration_value) once the market settles, and the series names who publishes it. Most daily temperature series name The Weather Company; a few name an NWS climatological report. Rows carry that name in settlement_source.

**Why can nws_observed_so_far_f be lower than the official high?**

It comes from the station's hourly NWS observations, and a station's official daily extreme is taken over every observation, so the hourly figure can sit slightly inside it. It exists for intraday context, not as a settlement value.

**What does it cost?**

$0.0012 per bracket row, no start fee. The order book and trade history are separate rows at $0.001 each and are off by default. The default of 100 markets costs about $0.12; 'Maximum markets' is your spend control.

**Do I need an account or a proxy?**

No. Kalshi and api.weather.gov are public, keyless APIs. The proxy input is off by default.

### Which actor to choose

Other Actors in the portfolio that pair with this one:

- **Kalshi & Polymarket Prediction Market Odds Scraper** — You want every Kalshi and Polymarket market, not only weather, ranked by volume.
- **Kalshi & Polymarket Order Book, 24h Change & Price History** — You want the order book, hourly price history and trades for named markets on either venue, not only weather.

### Guides & use cases

Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:

- **How-to:** [How to run Kalshi Weather Markets with NWS Forecast & Settlement](https://scrapebench.dev/guides/how-to-kalshi-weather-markets-nws-forecast-scraper/)
- **Use case:** [Kalshi NYC Temperature Brackets vs the NWS Forecast](https://scrapebench.dev/use-cases/kalshi-nyc-temperature-vs-nws-forecast/)

More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**

### Works with AI assistants (MCP)

Callable as an MCP tool, so Claude, Cursor, VS Code Copilot and other MCP clients can run it directly. Grab the config from the [MCP tab](https://apify.com/scrapebench/kalshi-weather-markets-nws-forecast-scraper/api/mcp) on this page — Apify hosts the server and keeps that snippet current, and OAuth signs you in on first connect, so no API token goes in your config file.

Then just ask:

> "Show me today's and tomorrow's open NYC high-temperature brackets on Kalshi with the NWS forecast and which brackets it lands in."

The input cities NYC, metrics high returned the open brackets with nws_forecast_temp_f and nws_forecast_in_bracket on 2026-11-16. Add days 2 to keep it to today and tomorrow. Runs started this way bill exactly like any other run.

### Data & lawful use

This actor collects publicly available information that Kalshi and the National Weather Service (NOAA) publishes for public
lookup — licence records, business listings and the contact details professionals list there.
Some of it identifies individuals (sole proprietors, licence holders, agents), so treat any
names, phone numbers and emails in your results as personal data.

When you run this actor, you decide what is collected and what it is used for, so you are the
controller of that data and we act only as your processor (Apify Standard Actor Contract).
You need a lawful basis for your use, must honour opt-out and deletion requests, and must
follow the marketing rules that apply to you (CAN-SPAM, TCPA, GDPR, CCPA and similar).
Don't use the output for unsolicited bulk messaging, for screening covered by the FCRA, or
for anything the source's own terms forbid.

Your results are stored in your own Apify account. We don't keep a copy of your results and
don't sell or share them.

### Disclaimer

This is an independent tool. It is not affiliated with, endorsed by or sponsored by
Kalshi and the National Weather Service (NOAA). Names and marks are used only to describe the data source. Records are
provided as published by the source and may be out of date or incomplete. For anything
consequential (hiring, a permit, a legal decision), confirm the record with the issuing
agency. You are responsible for making sure your use complies with applicable law and the
source's terms.

### Need help?

Open an issue on this actor's **Issues** tab and we'll respond there. Bug reports, missing
fields and feature requests are all welcome. Guides and examples: [scrapebench.dev](https://scrapebench.dev).

If you are a person named in this data and want your record removed from our copy, email
apify-help@scrapebench.dev; the source agency remains the official record.

Your run may be used to improve our services. If something looks off, or you want this actor to fit your use better, please share your run data with us: [Apify Console → Settings → Security → Share run data with developers](https://console.apify.com/settings/security). It lets us see exactly what went wrong and keep improving the actor.

If this actor saved you time, a short review on its Store page helps other buyers find it.

# Actor input Schema

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

Cities to read, as Kalshi names them: 'NYC', 'Chicago', 'Los Angeles', 'Miami', 'Denver', 'Austin'. Leave empty for every city. US cities get an NWS forecast; London, Tokyo, Paris and the rest are returned without one.

## `city` (type: `string`):

One city. Kept alongside 'Cities' for saved tasks and API callers.

## `metrics` (type: `array`):

high = daily high temperature, low = daily low temperature, rain = daily rain. Default: high and low.

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

open = markets still trading, with prices and forecast. settled = finished markets with the temperature that settled them.

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

Skip the city filter and name series directly: KXHIGHNY, KXLOWTEGLL (London low), KXRAINDNYC. Overrides 'Cities' and 'Markets to read'.

## `days` (type: `integer`):

Only markets for today and the next N-1 days. 0 = every open day.

## `minVolume` (type: `integer`):

Drop brackets with fewer contracts traded than this. Far-out brackets often sit at a cent with no trades.

## `dates` (type: `array`):

Only markets for these days (YYYY-MM-DD). Empty = every open day, or the last few days when settled.

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

For 'settled': how many days back to read.

## `includeForecast` (type: `boolean`):

Adds the National Weather Service forecast for each bracket's city and day, whether it falls inside the bracket and how far outside. US cities, about a week ahead.

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

One extra row per market with every resting yes and no price level and the depth. Billed per row.

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

One extra row per market with its most recent trades (time, price, size, taker side). Billed per row.

## `maxTrades` (type: `integer`):

How many recent trades to list per market when trade history is on.

## `maxResults` (type: `integer`):

Cap on market rows for the whole run: your spend control. Nearest day first, busiest brackets first. Order book and trade rows follow the markets returned.

## `proxyConfiguration` (type: `object`):

Optional and off by default: Kalshi and the National Weather Service are public, keyless APIs.

## Actor input object example

```json
{
  "cities": [
    "NYC"
  ],
  "metrics": [
    "high",
    "low"
  ],
  "status": "open",
  "seriesTickers": [],
  "days": 0,
  "minVolume": 0,
  "dates": [],
  "lookbackDays": 3,
  "includeForecast": true,
  "includeOrderbook": false,
  "includeTrades": false,
  "maxTrades": 50,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per bracket: prices, forecast, bracket fit, settlement.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebench/kalshi-weather-markets-nws-forecast-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": ["NYC"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapebench/kalshi-weather-markets-nws-forecast-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/hX0qgKRLNR5Mm9zXf/builds/TRwZASGCLjLO5StnY/openapi.json
