# Kalshi Weather Markets Scraper — Temps, Rain, Snow, All Cities (`tactful_anvil/kalshi-weather-markets-scraper`) Actor

Live bracket prices for every Kalshi weather market: daily high/low temps for all cities, rain, snow, hurricanes. Yes/no bid-ask, implied probability, volume, settled temps. Built on Kalshi's current dollars API. HTTP-only, no key. $0.80/1,000 markets.

- **URL**: https://apify.com/tactful\_anvil/kalshi-weather-markets-scraper.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:**
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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?

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 Scraper — every city, every bracket, $0.80/1,000 markets

Live bracket prices and recent settlements for **every Kalshi weather market**: daily high/low temperature for all listed cities (NYC, Chicago, Miami, Austin, Denver, LA, Philadelphia, Houston, Seattle, Toronto, London, and more), plus rain, snow and hurricane markets — **360+ series discovered automatically**, not a hardcoded city list.

Built on Kalshi's **current public trade API (the new `*_dollars` schema)** — the API migration that quietly broke older scrapers. Plain HTTP, no login, no API key, no browser, no proxies. Runs finish in seconds.

**$0.80 per 1,000 market records + $0.001 per start.** `maxMarkets` is a hard cost cap.

### Who uses this

- **Weather traders** — pull every open bracket with implied probability, volume and open interest before placing an order, instead of clicking through city pages.
- **Model builders** — join `settledValue` (the actual settled temperature) with your forecast data to backtest a strategy per city and station.
- **Dashboards & alerts** — schedule it and pipe fresh odds into Sheets, Slack or your own model.
- **AI agents** — stable flat schema, predictable cost, one-call market snapshot.

### What you get per market

| Field | Example | Notes |
|---|---|---|
| `seriesTicker` / `seriesTitle` | `KXHIGHNY` | which weather series |
| `eventTicker` | `KXHIGHNY-26AUG29` | one event = one city-day |
| `marketTicker` | `KXHIGHNY-26AUG29-B85.5` | one row per bracket |
| `bracket` | `85° to 86°` | human-readable strike |
| `strikeType`, `floorStrike`, `capStrike` | `between`, 85, 86 | machine-readable strike |
| `yesBid` / `yesAsk` / `noBid` / `noAsk` / `lastPrice` | `0.56` | dollars, parsed to numbers |
| `impliedProbability` | `0.565` | bid/ask mid (falls back to last price) |
| `volume`, `volume24h`, `openInterest`, `liquidity` | | activity metrics |
| `status`, `result` | `finalized`, `no` | settled markets carry the result |
| `settledValue` | `77` | **the actual settled temperature** |
| `station` | `CLINYC` | exact settlement weather station |
| `openTime` / `closeTime` / `expectedExpirationTime` | ISO | timing |
| `marketUrl` | | one-click open on Kalshi |

Every field is always present (nullable, never missing). `marketTicker` is a stable dedupe key.

### Input

```json
{
  "mode": "temperature",
  "cities": ["NY", "Chicago"],
  "status": "open",
  "maxMarkets": 500
}
```

- **mode** — `temperature` (every high/low/avg temp series) or `all-weather` (the entire Climate & Weather category: rain, snow, hurricanes too).
- **cities** — optional keyword filter (`["NY"]`, `["Denver", "Miami"]`). Empty = all cities.
- **seriesTickers** — exact series override, e.g. `["KXHIGHNY", "KXRAINDNYC"]`.
- **status** — `open` (live prices), `settled` (recent results + settled temps), or `both`.
- **settledLookbackDays** — how far back settled markets go (default 3).
- **maxMarkets** — hard cost cap ($0.80/1,000).

### How to schedule this Actor (recommended)

Weather odds move by the minute — this is built to run on a schedule:

1. Open the Actor → **Try for free**, set your cities and `status`.
2. Save as a task → **Schedules** → e.g. `*/30 * * * *` (every 30 min while markets are open) or `0 * * * *` hourly.
3. Add an integration (Google Sheets, Slack, webhook) so fresh brackets land where your model reads them.
4. For settlement tracking, a second daily task with `"status": "settled"` gives you yesterday's settled temperatures per station.

Monitoring 10 cities every 30 minutes typically costs a **few dollars a month** — the run is one row per bracket, and `maxMarkets` caps every run.

### Backtesting recipe

Run `"status": "settled", "settledLookbackDays": 90, "seriesTickers": ["KXHIGHNY"]` once: you get every bracket of every NYC high-temp market for the last 90 days with `result` and `settledValue` — join against your forecast history to measure edge per city.

### For AI agents & MCP

- Minimal input that just works: `{}` — scrapes all open temperature markets.
- Predictable cost: exactly `$0.0008 × markets` + `$0.001` per run.
- Stable schema, `marketTicker` dedupe key, `RUN_SUMMARY` in the key-value store.

### Related Actors

- **[Brand Ads Spy — Google + LinkedIn Ads in One Feed](https://apify.com/tactful_anvil/brand-ads-cross-network-spy)** — cross-network competitor ad intelligence.
- **[Superteam Earn Scraper](https://apify.com/tactful_anvil/superteam-earn-scraper)** — bounty and project boards with EV per entry.

### Fair use & data source

Only public market data from Kalshi's public trade API (the same data shown on kalshi.com). Reasonable rate limits (~2 req/s). No account data, no personal data, no order placement — **this is a read-only data tool, not a trading bot.** Not investment advice.

# Actor input Schema

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

Which Kalshi weather series to scrape. Temperature covers every KXHIGH\*/KXLOW\*/avg-temp series; all-weather covers the whole Climate and Weather category (360+ series).

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

Keep only series whose ticker/title mentions one of these, e.g. \["NY", "Chicago", "Denver"]. Empty = all cities.

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

Scrape exactly these series, e.g. \["KXHIGHNY", "KXLOWCHI", "KXRAINDNYC"].

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

Open = live tradable brackets. Settled = recent results incl. the actual settled temperature (settledValue).

## `settledLookbackDays` (type: `integer`):

When scraping settled markets, only include markets that closed within this many days.

## `maxSeries` (type: `integer`):

Cap on how many weather series to scan (daily series are prioritized).

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

Hard cost cap: at most this many market rows ($0.80 per 1,000).

## Actor input object example

```json
{
  "mode": "temperature",
  "status": "open",
  "settledLookbackDays": 3,
  "maxSeries": 60,
  "maxMarkets": 2000
}
```

# Actor output Schema

## `markets` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tactful_anvil/kalshi-weather-markets-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 = {}

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

```

## MCP server setup

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