THE COMPLETE GUIDE TO TRADING WEATHER MARKETS LIKE A QUANT
Source: http://x.com/i/article/2040192968972279809
One trader turned $100 into $5,000 trading the weather. Another one runs a fully automated bot that prints five figures a month. A third quit his job to do it full-time.
The market they use? It's been sitting right there on Polymarket - and 99% of users scroll past it every day.
Weather is not vibes. It's physics, data, and public forecast models that update every 6 hours. While the crowd guesses from a phone app, a small group of quant-minded traders built systematic edges on top of NOAA and Open-Meteo APIs - and quietly farmed serious money.
This piece breaks down exactly how they do it:
- Who the main weather traders are and what their P&L looks like
- How Polymarket weather markets actually work (mechanics, buckets, edge)
- The full tool stack: forecast APIs, visual models, Polymarket data
- Working Python code to build your own edge-detection system
1. Where the money is: Polymarket weather 101
1.1 Types of weather markets
On Polymarket you trade outcome shares: each contract goes from 0 to 1, and resolves at 1 if the outcome happens, 0 otherwise.
The climate & weather vertical has three main buckets:
- Daily temperature – “Highest temperature in Shanghai on April 4?”, “Highest temperature in NYC on March 31?”, etc.
- Short‑term events – “Where will it snow this December?”, specific cold waves/heatwaves.
- Climate milestones – “Will 2025 be the hottest year on record?”, seasonal or yearly anomalies.
In daily high markets:
- You see 8-12 temperature buckets (for example 25°C, 26°C, 27°C, … 32°C+).
- Each bucket trades separately; the sum of their prices roughly hovers around 1.
- At settlement, Polymarket looks at a specific weather station (airport, city station) and pays 1 only on the bucket that matches the official high.
1.2 Why this niche is so clean
Weather has a few properties traders love:
- Heavy modeling by national agencies and private providers.
- Public access to high‑quality forecasts and historical error statistics.
- Clear resolution rules (exact station, exact time window), so you know what data matters.
The edge is simple:
crowd trades off a single phone app, quants trade off multi‑model ensembles + scripts.
2. The current weather “cartel”: who’s actually winning
A handful of names come up again and again in articles, leaderboards and on‑chain analytics.
- neobrother – systematic temperature ladders across global cities (Buenos Aires, Miami, Ankara, Chicago, NYC), 3 000+ daily‑high markets and 5‑figure cumulative profit Profile:polymarket.com/@neobrother
- Hans323 – specializes in rare but huge tail trades; most famously Polymarket trader with 2,800+ positions Profile:polymarket.com/@hans323
- Handsanitizer23 – high‑precision, low‑count weather quant who flipped a sub‑4‑figure bankroll into tens of thousands with only a few dozen predictions; one viral example shows ~$600 → $16k on a single temperature market. Profile:polymarket.com/@handsanitizer23
- ColdMath – thousands of predictions with very high long‑run win rate in temperature markets; often cited in threads as one of the most consistent weather specialists. Profile:polymarket.com/@coldmath
- HondaCivic – aggressive sizing, Top 0.01% $1k → $ 80k; frequently referenced as part of the “weather cartel” on X. Profile:polymarket.com/@hondacivicProfile 2:polymarket.com/@hondacivic2
- BeefSlayer – diversified but heavily skewed to weather, strong accuracy across dozens of cities; long‑form breakdowns show him alongside ColdMath and HondaCivic as a core weather quant. Profile:polymarket.com/@beefslayer
- Bots (e.g. automated AI trading bot) – fully automated Clawdbot‑style systems with several thousand weather predictions and 5‑figure PnL, proving that a small statistical edge plus automation scales well. Covered in multiple exchange and community articles about weather bots.
3. Playbook: how they actually trade weather
3.1 Temperature laddering (neobrother style)
Think of laddering as trading a band instead of a point.
Typical setup described in Odaily / KuCoin pieces:
- Market: “Highest temperature in Buenos Aires on March 10?”
- Buckets: 24°C, 25°C, 26°C, 27°C, 28°C, 29°C+.
- Model distribution says “most likely 26–28°C, long right tail”.
What a ladder trader does:
- Buys small size in 25°C, 26°C, 27°C, 28°C, 29°C+ at very cheap prices (often 0.7–5¢ per share).
- Sizes a bit larger in the bucket where probability minus price gap is largest.
- Accepts that 3–4 legs will expire worthless, because the winner bought at 1–5¢ pays out at 1.
One hit at 0.7¢ → 1.00 is a multiple of ~142× on that leg; even with several small losses the ladder as a whole is positive EV.
Laddering = smoothing variance while still hunting for big multiples.
3.2 Bots and “Clawbot” systems
Community guides show a fairly standard architecture for weather bots:
Data layer Pull forecast data from APIs (NOAA, Open‑Meteo, ECMWF/C3S).
Model layer
Convert forecast into probabilities per bucket.
Execution layer
Watch Polymarket prices via API / WebSocket. When price << probability (by some threshold), place buy orders. Optionally sell overpriced buckets.
Bots like automated AI trading bot show thousands of weather predictions and 5‑figure realized profit just from repeating this logic.
https://x.com/0xMovez/status/2020586519002501435
4. The tool stack: sites, maps, APIs – and code
4.1 Forecast APIs & data sources
These are the workhorses behind most serious systems:
- NOAA / National Weather Service API –https://api.weather.govForecasts and grid data for US locations, official government source.
- Open‑Meteo –https://open-meteo.comFree, open‑source API aggregating multiple models; includes historical and forecast data, no API key needed.
- ECMWF / Copernicus Climate Data Store (C3S) –https://cds.climate.copernicus.euAccess to ECMWF ensemble forecasts and seasonal products, good for distribution tails.
- Commercial APIs (
Tomorrow.io, Meteomatics, etc.) Paid, high‑resolution forecasts used by energy traders; relevant once size and seriousness justify the spend.
Minimal Python example: pulling a forecast from Open‑Meteo. python
import requests
import pandas as pd
LAT, LON = 40.7812, -73.9665 # Example: NYC
url = "https://api.open-meteo.com/v1/forecast"
params = {
"latitude": LAT,
"longitude": LON,
"hourly": "temperature_2m",
"forecast_days": 2,
"timezone": "UTC",
}
resp = requests.get(url, params=params, timeout=10)
resp.raise_for_status()
data = resp.json()
hourly = pd.DataFrame(data["hourly"])
hourly["time"] = pd.to_datetime(hourly["time"])
print(hourly.head())
4.2 Visual model viewers
For intuition and manual checks:
Windy.comMulti‑model viewer (ECMWF, GFS, ICON, etc.), animated global maps of temperature, wind, precipitation.- VentuskyInteractive weather map with dozens of layers; especially good for visualizing temperature and precipitation fields.
Windy.app–https://windy.appFocused on sports but exposes multiple forecast models and quick comparison by location.
Practical workflow:
- Script says “Chicago bucket 7 is cheap.”
- Open Windy / Ventusky at that time to see if synoptic picture supports the trade.
4.3 Polymarket side: data & execution
To connect your weather insight to actual positions:
- UsePolymarket docs & APIsfor market discovery and order routing.
- Watch live prices via WebSockets to catch moves after model updates.
- Track leaderboards in the Climate & Weather category to see who is consistently profitable and how many trades they run.
The clean public route is to use the Gamma API and fetch the market by slug.
python
import requests
import json
GAMMA_BASE = "https://gamma-api.polymarket.com"
def fetch_market_by_slug(slug: str) -> dict:
url = f"{GAMMA_BASE}/markets"
params = {
"slug": slug,
"active": "true",
}
resp = requests.get(url, params=params, timeout=10)
resp.raise_for_status()
markets = resp.json()
if not markets:
raise ValueError(f"No markets found for slug: {slug}")
return markets[0]
def fetch_outcome_prices(slug: str) -> dict:
market = fetch_market_by_slug(slug)
outcomes = json.loads(market["outcomes"])
prices = json.loads(market["outcomePrices"])
return {
outcome: float(price)
for outcome, price in zip(outcomes, prices)
}
5. Building a real edge: step‑by‑step (with code)
5.1 Pick a small universe
Start narrow:
- 2–3 cities you understand seasonally (for example NYC, Chicago, Dallas).
- Only daily‑high markets for the next 1–3 days.
Reasons:
- Faster feedback loop.
- You see how models behave in different regimes for the same geography.
5.2 Turn forecasts into bucket probabilities
Now that you have hourly temperatures, the simplest first approximation is:
- take the forecast daily max,
- assume some forecast uncertainty,
- simulate a distribution around that value,
- integrate that distribution across market buckets.
Example: quick‑and‑dirty Monte Carlo around the day’s forecast maximum.
python
import numpy as np
import pandas as pd
market_date = hourly["time"].dt.date.iloc[0]
day = hourly[hourly["time"].dt.date == market_date]
point_forecast = day["temperature_2m"].max()
sigma = 1.5 # assumed forecast error in °C
bucket_specs = [
((24, 25), "24°C"),
((25, 26), "25°C"),
((26, 27), "26°C"),
((27, 28), "27°C"),
((28, 29), "28°C"),
((29, 100), "28°C or higher"),
]
def bucket_probability(lo, hi, mu, sigma, n=50000):
samples = np.random.normal(mu, sigma, size=n)
return ((samples >= lo) & (samples < hi)).mean()
rows = []
for (lo, hi), label in bucket_specs:
p = bucket_probability(lo, hi, point_forecast, sigma)
rows.append({
"outcome": label,
"model_prob": p,
})
prob_df = pd.DataFrame(rows)
prob_df["model_prob"] = prob_df["model_prob"] / prob_df["model_prob"].sum()
print(prob_df)
Important detail: the labels in bucket_specs should match the exact outcome labels in the Polymarket market you are studying. If they do not match, your map() step later will fail.
5.3 Compare probabilities with Polymarket prices
Once you have model probabilities and fetched market prices, the comparison is simple.
python
slug = "highest-temperature-in-nyc-on-april-2-2026"
pm_prices = fetch_outcome_prices(slug)
prob_df["market_price"] = prob_df["outcome"].map(pm_prices)
prob_df["edge"] = prob_df["model_prob"] - prob_df["market_price"]
edges = prob_df.sort_values("edge", ascending=False)
print(edges)
That gives you the core output that matters:
- what your model thinks,
- what the market implies,
- and where the spread is biggest.
That spread is your potential edge.
5.4 First trades: manual laddering
Before automation, you want intuition.
For each market:
- Identify 3-6 buckets where probability minus price is positive.
- Size them so that: Worst case: all expire at 0 → still tiny % of bankroll. Typical case: one big winner repays the rest + profit.
Think in series of markets, not one‑off hero calls.
5.5 Logging results into your own dataset
Even if trades are manual, logging should be automatic.
python
from pathlib import Path
import csv
from datetime import datetime
LOG_PATH = Path("weather_polymarket_log.csv")
def log_market(city, market_date, bucket, prob, price, edge, final_bucket=None):
is_new = not LOG_PATH.exists()
with LOG_PATH.open("a", newline="") as f:
writer = csv.writer(f)
if is_new:
writer.writerow([
"timestamp",
"city",
"market_date",
"bucket",
"model_prob",
"market_price",
"edge",
"final_bucket",
])
writer.writerow([
datetime.utcnow().isoformat(),
city,
market_date.isoformat(),
bucket,
round(prob, 4),
round(price, 4),
round(edge, 4),
final_bucket or "",
])
best = edges.iloc[0]
log_market(
city="NYC",
market_date=market_date,
bucket=best["outcome"],
prob=best["model_prob"],
price=best["market_price"],
edge=best["edge"],
)
5.6 Semi‑automatic alert loop
Before a full bot, build a monitor.
This version is intentionally simple:
python
import time
import requests
import json
import numpy as np
import pandas as pd
GAMMA_BASE = "https://gamma-api.polymarket.com"
def fetch_market_by_slug(slug: str) -> dict:
url = f"{GAMMA_BASE}/markets"
params = {
"slug": slug,
"active": "true",
}
resp = requests.get(url, params=params, timeout=10)
resp.raise_for_status()
markets = resp.json()
if not markets:
raise ValueError(f"No markets found for slug: {slug}")
return markets[0]
def fetch_outcome_prices(slug: str) -> dict:
market = fetch_market_by_slug(slug)
outcomes = json.loads(market["outcomes"])
prices = json.loads(market["outcomePrices"])
return {outcome: float(price) for outcome, price in zip(outcomes, prices)}
def fetch_hourly_forecast(lat: float, lon: float) -> pd.DataFrame:
url = "https://api.open-meteo.com/v1/forecast"
params = {
"latitude": lat,
"longitude": lon,
"hourly": "temperature_2m",
"forecast_days": 1,
"timezone": "UTC",
}
resp = requests.get(url, params=params, timeout=10)
resp.raise_for_status()
data = resp.json()
hourly = pd.DataFrame(data["hourly"])
hourly["time"] = pd.to_datetime(hourly["time"])
return hourly
def build_probability_table(hourly: pd.DataFrame, bucket_specs, sigma=1.5) -> pd.DataFrame:
market_date = hourly["time"].dt.date.iloc[0]
day = hourly[hourly["time"].dt.date == market_date]
point_forecast = day["temperature_2m"].max()
def bucket_probability(lo, hi, mu, sigma, n=50000):
samples = np.random.normal(mu, sigma, size=n)
return ((samples >= lo) & (samples < hi)).mean()
rows = []
for (lo, hi), label in bucket_specs:
p = bucket_probability(lo, hi, point_forecast, sigma)
rows.append({
"outcome": label,
"model_prob": p,
})
df = pd.DataFrame(rows)
df["model_prob"] = df["model_prob"] / df["model_prob"].sum()
return df
def compute_edges(slug: str, lat: float, lon: float, bucket_specs):
hourly = fetch_hourly_forecast(lat, lon)
prob_df = build_probability_table(hourly, bucket_specs)
pm_prices = fetch_outcome_prices(slug)
prob_df["market_price"] = prob_df["outcome"].map(pm_prices)
prob_df["edge"] = prob_df["model_prob"] - prob_df["market_price"]
return prob_df.sort_values("edge", ascending=False)
slug = "highest-temperature-in-nyc-on-april-2-2026"
LAT, LON = 40.7812, -73.9665
bucket_specs = [
((24, 25), "24°C"),
((25, 26), "25°C"),
((26, 27), "26°C"),
((27, 28), "27°C"),
((28, 29), "28°C"),
((29, 100), "28°C or higher"),
]
while True:
edges = compute_edges(slug, LAT, LON, bucket_specs)
print(edges[["outcome", "model_prob", "market_price", "edge"]].head())
time.sleep(60 * 30)
This is probably the strongest code block for the article because it demonstrates the full loop:
- weather forecast,
- Polymarket prices,
- probability model,
- edge ranking.
And it does it without pretending to place orders
6. Risks, moving edges, and why this still matters
Real talk checklist:
- Model error: fronts shift, storms pop up, micro‑climates ruin clean distributions.
- Liquidity: some city markets are thin; your own orders can move the price.
- Platform risk: smart‑contract, custody and regulatory risk around on‑chain markets.
- Crowding: every article like this pushes more quants into the niche; edges compress over time.
The upside:
- As long as most participants use one weather app and intuition, and only a minority plug into NOAA/Open‑Meteo/ECMWF with scripts, there will be mispricings.
- Weather is one of the rare places where you can go from “tourist” to “local pro” mostly by doing homework and building a small tool stack.
7. TL;DR playbook
If you skimmed everything, here’s the compressed version:
- Go topolymarket.com/weatherand pick 2–3 cities
- Pull forecasts from NOAA / Open‑Meteo for those exact stations
- Convert forecasts into bucket probabilities (the Monte Carlo snippet above is enough for v1)
- Ladder into the underpriced buckets instead of aiming for one exact number
- Log everything. After 50-100 markets, keep only what works net of fees
- Automate data pulls and alerts; only then think about full bots
- Keep tails small, but do not ignore them – that’s where Hans323‑style payoffs live
That’s the path that turned weather from background noise into a serious on‑chain edge for traders like neobrother, Handsanitizer23, ColdMath, HondaCivic and BeefSlayer – and it’s still open to anyone willing to build the stack instead of guessing.

GIF
Want to start without building the stack yourself?
The traders in this article are live on Kreo - a copy-trading platform where you can mirror their weather positions in real time.
- Follow the top weather traders directly:**kreo.app/@trade**
You'll see their open positions, win rates, and track record. One click to copy.
If you found this useful - follow me
@polydao
for daily alpha on Polymarket: market breakdowns, trader profiles, and the strategies that actually work.
I cover weather markets, political contracts, and the quant edges most people miss. Drop a like if this helped - it tells me to write more of this.