# Kalshi Weather Index – Minute Temperature Data for 10 Cities (`gratified_ashram/kalshi-weather-index`) Actor

Kalshi's official minute-by-minute city temperature index, the series that settles its hourly and daily temperature markets. One row per minute per city, with status and station count. Public API, no login. Pay per 1,000 points delivered.

- **URL**: https://apify.com/gratified\_ashram/kalshi-weather-index.md
- **Developed by:** [Tit Slobodjanac](https://apify.com/gratified_ashram) (community)
- **Categories:** Developer tools, News, Sports
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 index points

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 Index — minute-by-minute city temperature, the series that settles Kalshi's temperature markets

Kalshi publishes its own **temperature index** for ten US metro areas: one value per minute, computed from a quorum of weather stations, versioned and calibrated. It is the number that settles Kalshi's hourly and daily temperature markets (`KXTEMP…`, `KXHIGH…`, `KXLOW…`). This Actor pulls that series into a dataset — one row per minute per city — so you can backtest, build forecasts against the exact settlement source, or keep a history Kalshi itself only serves as a rolling window.

Source: Kalshi's public live-data endpoint. **No Kalshi account, no API key, no scraping.** Runs cost cents and do not break.

### Cities

`miami`, `dfw` (Dallas–Fort Worth), `houston`, `phl-delaware-valley` (Philadelphia), `puget-sound` (Seattle), `sf-bay`, `greater-boston`, `southeast-michigan` (Detroit), `kansas-city`, `minneapolis-st-paul`. Leave the list empty for all ten.

### Input

```json
{ "cities": ["miami", "greater-boston"], "lastHours": 24, "detailed": false, "archiveDatasetName": "kalshi-weather-index" }
```

| Field | What it does |
|---|---|
| `cities` | Index city IDs (above). Empty = all ten. |
| `lastHours` | Trailing window, 1–168 hours. 60 points per hour per city. |
| `from` / `to` | Explicit window instead (ISO time or unix milliseconds). |
| `detailed` | Attach every member station's reading and quality-control disposition to each point. |
| `maxItems` | Cost cap per run. |
| `archiveDatasetName` | Also append to a named dataset in your account. Schedule hourly and you keep the full history. |

### Output

```json
{
  "city": "miami",
  "time": "2026-09-03T10:56:00.000Z",
  "timestampMs": 1788432960000,
  "temperatureF": 79.52,
  "temperatureC": 26.4,
  "status": "normal",
  "contributors": 5,
  "configVersion": "miami-temperature-v1.0-cal-20260831",
  "units": "fahrenheit",
  "fetchedAt": "2026-09-03T11:56:26.995Z"
}
```

`status` is `normal`, `degraded` or `incomplete`. Minutes where the station quorum failed are absent from Kalshi's series and therefore absent here — a gap is a real gap, never interpolated. `configVersion` changes when Kalshi recalibrates the index; keep it if you compare across weeks.

### What people use it for

- **Backtesting temperature-market strategies** against the exact series that settles them, not a nearby airport's METAR.
- **Forecast calibration**: compare your model or a public ensemble to the index minute by minute.
- **Live dashboards and alerts** for hourly temperature markets: schedule every 15 minutes with `lastHours: 1`.
- **History**: Kalshi serves a window; with `archiveDatasetName` and a daily schedule you own the archive.

Pairs with [Prediction Markets Scraper](https://apify.com/gratified_ashram/prediction-markets-scraper) for the market prices themselves (`kalshiSeriesTickers: ["KXTEMP*", "KXHIGH*", "KXLOW*"]`).

### Pricing

Pay per 1,000 index points delivered. Platform usage included. A run that returns nothing costs nothing.

***

Found it useful? A review on the Actor page helps other people find it. Missing a city or a field? Open an issue.

# Actor input Schema

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

Kalshi index city IDs. Leave empty for all ten.

## `lastHours` (type: `integer`):

How many hours back from now to pull, per city. 1–168. Ignored when from/to are set. 60 points per hour per city.

## `from` (type: `string`):

Optional window start, e.g. 2026-09-01T00:00:00Z. Use with To.

## `to` (type: `string`):

Optional window end. Defaults to now.

## `detailed` (type: `boolean`):

Attach every member station's reading and quality-control disposition to each point (Kalshi's detailed=true). Larger rows, same price.

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

Cost cap per run. 1,000 points = one city for about 17 hours.

## `archiveDatasetName` (type: `string`):

Also append points to a named dataset in your account (e.g. kalshi-weather-index). Schedule hourly and you keep a history Kalshi only serves as a window.

## `compact` (type: `boolean`):

Group the minutes of each hour into one row per city with a minutes array plus min/max. 60× fewer dataset rows, same data, same price (per index point). Good for archiving.

## `archiveOnly` (type: `boolean`):

With an archive dataset set: write only to the archive, not to this run's dataset. Halves storage writes on scheduled runs.

## `alignToHour` (type: `boolean`):

End the window at the last completed hour instead of now. With lastHours 1 on a schedule at minute 10, each run covers exactly the previous hour.

## Actor input object example

```json
{
  "cities": [
    "miami",
    "dfw",
    "houston"
  ],
  "lastHours": 24,
  "detailed": false,
  "maxItems": 20000,
  "compact": false,
  "archiveOnly": false,
  "alignToHour": false
}
```

# Actor output Schema

## `points` (type: `string`):

One row per minute per city: time, temperature in °F and °C, status, contributing station count, index configuration version.

## `summary` (type: `string`):

Points pushed per city, the window covered, and any per-window errors.

# 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": [
        "miami",
        "dfw",
        "houston"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gratified_ashram/kalshi-weather-index").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": [
        "miami",
        "dfw",
        "houston",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("gratified_ashram/kalshi-weather-index").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": [
    "miami",
    "dfw",
    "houston"
  ]
}' |
apify call gratified_ashram/kalshi-weather-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gratified_ashram/kalshi-weather-index"
        }
    }
}

```

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/PDg0TFgjc2iw7yjjs/builds/hwtYTc3IsynraR05C/openapi.json