530 lines
20 KiB
Markdown
530 lines
20 KiB
Markdown
---
|
||
title: "THE COMPLETE GUIDE TO TRADING WEATHER MARKETS LIKE A QUANT"
|
||
source: "https://x.com/polydao/status/2041113454023475370"
|
||
author:
|
||
- "[[@polydao]]"
|
||
published: 2026-02-09
|
||
created: 2026-04-26
|
||
description: "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 qui..."
|
||
tags:
|
||
- "clippings"
|
||
---
|
||

|
||
|
||
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](https://polymarket.com/@neobrother?via=dao)
|
||
|
||

|
||
|
||
- **Hans323** – specializes in rare but huge tail trades; most famously Polymarket trader with 2,800+ positions Profile: [polymarket.com/@hans323](https://polymarket.com/@hans323?via=dao)
|
||
|
||

|
||
|
||
- **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](https://x.com/search?q=%2416k&src=cashtag_click) on a single temperature market. Profile: [polymarket.com/@handsanitizer23](https://polymarket.com/@handsanitizer23?via=dao)
|
||
|
||

|
||
|
||
- **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](https://polymarket.com/@coldmath?via=dao)
|
||
|
||

|
||
|
||
- **HondaCivic** – aggressive sizing, Top 0.01% [$1k](https://x.com/search?q=%241k&src=cashtag_click) → $ 80k; frequently referenced as part of the “weather cartel” on X. Profile: [polymarket.com/@hondacivic](https://polymarket.com/@hondacivic?via=dao) Profile 2: [polymarket.com/@hondacivic2](https://polymarket.com/@hondacivic2?via=dao)
|
||
|
||

|
||
|
||

|
||
|
||
- **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](https://polymarket.com/@beefslayer?via=dao)
|
||
|
||

|
||
|
||
- **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:
|
||
|
||
1. **Data layer** Pull forecast data from APIs (NOAA, Open‑Meteo, ECMWF/C3S).
|
||
2. **Model layer** Convert forecast into probabilities per bucket.
|
||
3. **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.
|
||
|
||
> 2月9日
|
||
|
||
# 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.gov](https://api.weather.gov/) Forecasts and grid data for US locations, official government source.
|
||
- **Open‑Meteo** – [https://open-meteo.com](https://open-meteo.com/) Free, 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.eu](https://cds.climate.copernicus.eu/) Access to ECMWF ensemble forecasts and seasonal products, good for distribution tails.
|
||
- **Commercial APIs** ([Tomorrow.io](https://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.com](https://windy.com/) Multi‑model viewer (ECMWF, GFS, ICON, etc.), animated global maps of temperature, wind, precipitation.
|
||
- [Ventusky](https://www.ventusky.com/) Interactive weather map with dozens of layers; especially good for visualizing temperature and precipitation fields.
|
||
- [Windy.app](https://windy.app/) – [https://windy.app](https://windy.app/) Focused 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:
|
||
|
||
- Use [Polymarket docs & APIs](https://docs.polymarket.com/api-reference/introduction) for 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:
|
||
|
||
1. Go to [polymarket.com/weather](https://polymarket.com/weather?via=dao) and pick 2–3 cities
|
||
2. Pull forecasts from **NOAA** / **Open‑Meteo** for those exact stations
|
||
3. Convert forecasts into bucket probabilities (the Monte Carlo snippet above is enough for v1)
|
||
4. Ladder into the underpriced buckets instead of aiming for one exact number
|
||
5. Log everything. After 50-100 markets, keep only what works net of fees
|
||
6. Automate data pulls and alerts; only then think about full bots
|
||
7. 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.
|
||
|
||
<video preload="auto" tabindex="-1" playsinline="" aria-label="嵌入式视频" poster="https://pbs.twimg.com/tweet_video_thumb/HFFV7m3WoAA5aGl.jpg" src="https://video.twimg.com/tweet_video/HFFV7m3WoAA5aGl.mp4" type="video/mp4" style="width: 100%; height: 100%; position: absolute; background-color: black; top: 0%; left: 0%; transform: rotate(0deg) scale(1.005);"></video>
|
||
|
||

|
||
|
||
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](https://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](https://x.com/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. |