Kalshi Weather Bot (2026): How to Build One With the API

What are Kalshi's weather markets?

Kalshi groups them under its Climate and Weather category, which held 411 series when this was written. The ones bots care about most are the daily temperature markets: 48 daily-high series, with tickers starting KXHIGH, and 54 daily-low series starting KXLOW. They cover major US cities and a growing list of international ones, from Tokyo and Singapore to Paris, Toronto and São Paulo. There is also an hourly directional series for New York, KXHIGHNYD.

Check the settlement source for every series you trade, because it is not the same everywhere. Most daily-high series settle on The Weather Company, while a few, such as the Houston series above, settle on a National Weather Service climatological report.

How is a Kalshi temperature market structured?

Each series creates one event per day, and each event splits the day's high into mutually exclusive markets. For New York on 27 September 2026, the event KXHIGHNY-26SEP27 held six markets:

Exactly one of the six pays out. The market rules resolve on the maximum temperature recorded at New York City's CLINYC station for that date, according to The Weather Company, and trading closes at 05:00 UTC the following day. Kalshi's rules also warn that preliminary readings can differ from the final value through rounding and conversion, so the number that counts is the final one.

How do you pull Kalshi's weather markets from the API?

Market data needs no account. Kalshi's own market-data quickstart uses this exact series:

import requests

BASE = "https://external-api.kalshi.com/trade-api/v2"

resp = requests.get(f"{BASE}/markets", params={"series_ticker": "KXHIGHNY", "status": "open"})
markets = resp.json()["markets"]
for m in markets:
    print(m["ticker"], m["strike_type"], m.get("floor_strike"), m.get("cap_strike"),
          m["yes_bid_dollars"], m["yes_ask_dollars"])

Where does the temperature signal come from?

Two free sources cover most bots: a forecast for the day, and a live reading as the day unfolds.

The forecast. The US National Weather Service publishes free forecasts through api.weather.gov. A point lookup resolves coordinates to a forecast grid, and the hourly forecast gives you the day's expected high:

headers = {"User-Agent": "my-weather-bot (you@example.com)"}

point = requests.get("https://api.weather.gov/points/40.7829,-73.9654", headers=headers).json()
hourly = requests.get(point["properties"]["forecastHourly"], headers=headers).json()

day = "2026-09-27"
temps = [p["temperature"] for p in hourly["properties"]["periods"] if p["startTime"][:10] == day]
forecast_high = max(temps)

The live reading. Kalshi publishes its own minute-level temperature index, free and without a key, for 13 cities: nyc, chicago, miami, dfw, houston, la-coastal, sf-bay, puget-sound, greater-boston, phl-delaware-valley, southeast-michigan, kansas-city and minneapolis-st-paul.

idx = requests.get(f"{BASE}/live_data/weather/nyc", params={"last_sec": 3600}).json()
latest = idx["timeseries"][-1]
print(latest["v"], latest["status"], latest["contributors"])

How do you turn a forecast into bracket prices?

Treat the forecast as a distribution rather than a number. With a forecast high and an estimate of its error, the chance of each bracket follows from the normal distribution, using half-degree edges because the brackets are defined in whole degrees:

from math import erf, sqrt

def p_below(x, mean, sd):
    return 0.5 * (1 + erf((x - mean) / (sd * sqrt(2))))

def bracket_probability(m, mean, sd):
    lo, hi = m.get("floor_strike"), m.get("cap_strike")
    if m["strike_type"] == "greater":   # e.g. 73 degrees or above
        return 1 - p_below(lo + 0.5, mean, sd)
    if m["strike_type"] == "less":      # e.g. 64 degrees or below
        return p_below(hi - 0.5, mean, sd)
    return p_below(hi + 0.5, mean, sd) - p_below(lo - 0.5, mean, sd)

for m in markets:
    fair = bracket_probability(m, mean=forecast_high, sd=2.0)
    ask = float(m["yes_ask_dollars"])
    if fair - ask > 0.05:   # leave room for fees and model error
        print("candidate", m["ticker"], round(fair, 2), ask)

How do you test a Kalshi weather bot before risking money?

In two passes. First backtest the pricing logic against settled days, using Kalshi's market history, covered in Kalshi historical data. Then run the whole loop live without real orders.

For the live pass, Predictefy's paper trading fills simulated orders against Kalshi's real order book from a simulated USD balance. It costs 0 credits and is included on every plan, including Free:

import uuid
from predictefy import Predictefy

client = Predictefy(api_key="pk_live_YOUR_KEY")

order = client.place_paper_order(
    "kalshi", "MARKET_ID", "OUTCOME_ID", "buy", 0.24, 20,
    tif="GTC",
    idempotency_key=str(uuid.uuid4()),
)
positions = client.paper_positions()

What trips up Kalshi weather bots?

• The wrong thermometer. Markets settle on the named station's value from the named source. Kalshi's rules say other weather sources may guide you but are not the official value.
• Preliminary numbers. Early readings can shift through rounding and conversion before the final value is published.
• Thin tails. Tail markets often show no bid and a 1-cent ask. A price there says little about real liquidity.
• The clock. Trading runs until 05:00 UTC the next day, and a late-evening front can still move the high. Decide in advance when your bot stops trading a day.
• Degraded data. When the index reports degraded or goes quiet, pause rather than trade on a stale view.

For order placement itself, the V2 order methods are covered in the Kalshi SDK guide, and a full bot structure in how to build a Kalshi trading bot.

Frequently Asked Questions