Polymarket Weather Trading Bot — Live

WeatherBot

The #1 Polymarket Weather Trading Bot

Powered by Polymarket + Claude AI

The easiest way to trade weather on Polymarket. Real-time streaming via Polymarket WebSocket, AI-powered edge detection by Claude Sonnet, and automated Kelly-criterion execution across 67+ global cities.

Start Trading
$2.87M
Member realized P&L
9,592
Registered traders
71-80%
Average win rate
$7.5M
Volume traded (30 days)
$445
Avg profit / funded account
2,359
Active this month
67+
Global Cities Tracked
5
Forecast Models (GFS, ECMWF, UKMO, NWS, HKO)

Get Started in 2 Minutes

Watch the Tutorial

Everything you need to start trading weather on Polymarket — bot setup, wallet connection, trading modes, and your first auto-executed trade.

Architecture

How This Polymarket Weather
Trading Bot Actually Works

WeatherBot is a Node.js Express server that connects to Polymarket's CLOB via WebSocket, fetches forecasts from up to 5 real weather APIs (including the Hong Kong Observatory — the official gauge that settles Hong Kong markets), calculates probabilistic edge with Bayesian statistics, and executes trades with Claude AI as the final decision maker.

5-Source Ensemble Forecasting

Fetches real-time data from GFS (NOAA 16-day), ECMWF (European 10-day), UKMO (UK Met Office 7-day), and NWS (US hourly) — plus HKO (Hong Kong Observatory) for Hong Kong, the official gauge Polymarket settles HK markets on. Weighted consensus (ECMWF 0.35, GFS 0.25, UKMO 0.20, NWS 0.20) with outliers auto-penalized at 0.5x weight; for Hong Kong, HKO dominates at 0.50 and tapers by lead time.

Hong Kong Resolution-Source Lock

For Hong Kong, the engine reads HKO's live HQ gauge — the exact number the market settles on — every few minutes on resolution day. A daily maximum can only rise, so once it crosses a threshold that outcome is locked YES; the bot buys it while it's still mispriced (35–83¢ band) and runs a mirror play once the afternoon peak has passed.

Bayesian Edge Calculator

Dynamic σ from forecast horizon (0.8° at 6h to 5.5° at 10d+). Normal CDF probability per outcome, Bayesian blending with NOAA NCEI 10-year historical base rates, Kelly criterion sizing capped at quarter-Kelly (max 15% bankroll).

Real-Time WebSocket Streaming

Connects to wss://ws-subscriptions-clob.polymarket.com/ws/market and subscribes to all weather token IDs. On every price_change event, instantly recalculates edge. Sub-2-second from price tick to trade execution.

Claude AI Decision Engine

Claude Sonnet analyzes each market with full forecast data, model agreement scores, historical base rates, and current prices. Returns BUY_YES/BUY_NO/SKIP with confidence tier (VERY_HIGH to LOW) and suggested position size. AI cycle runs every 5-15 minutes.

67 Global Cities

Covers New York, London, Tokyo, Paris, Berlin, Sydney, Dubai, Seoul, and 59 more cities. Auto-detects city and date from Polymarket question titles, maps to lat/lon coordinates, and fetches localized forecasts in °F or °C.

5-Layer Exit System

Profit target (60% edge captured), edge convergence (<2% remaining), trailing stop (40% pullback from peak), stop loss (-15%), and time decay exit (within 2h of resolution). Auto-sells via Polymarket CLOB when triggered.

How the Polymarket Weather Trading Bot Works

Scan → Forecast → Edge → Trade
in 3 Automated Steps

WeatherBot automates the entire Polymarket weather trading pipeline. Connect your Polygon wallet, configure your settings, hit Start, and the bot handles everything — from market discovery to on-chain trade execution with AI-powered edge detection.

1. Market Discovery + Forecasting

Queries Polymarket Gamma API for all weather-tagged events. Parses market titles to extract city, date, and temperature unit. Fetches GFS, ECMWF, UKMO, and NWS forecasts in parallel via Open-Meteo and api.weather.gov. Loads NOAA NCEI historical base rates (10 years) per city/date.

2. Edge Calculation + AI Analysis

EdgeCalculator builds weighted consensus temperature, calculates dynamic σ (uncertainty) based on hours-to-resolution and model spread, then runs Normal CDF probabilities for each outcome. Claude AI receives all data and returns structured JSON: decision, outcome, confidence, reasoning, and suggested size.

3. WebSocket Streaming + Auto-Execution

StreamEngine connects to Polymarket WebSocket, subscribing to all weather token IDs. On every price tick, edge is recalculated instantly. If edge exceeds threshold (3-8% dynamic), the Trader class executes via FOK market order (fallback: GTC limit with 2% slippage). Positions are tracked with 5-layer exit monitoring.

FAQ

Frequently Asked Questions
About the Polymarket Weather Trading Bot

WeatherBot fetches from 5 production weather APIs: GFS via Open-Meteo (NOAA, 16-day), ECMWF via Open-Meteo (European Centre, 10-day), UKMO via Open-Meteo (UK Met Office, 7-day), NWS direct from api.weather.gov (US-only hourly + alerts), and — for Hong Kong — the Hong Kong Observatory (HKO) Open Data API, the official gauge Polymarket uses to resolve Hong Kong markets (9-day forecast plus a live hourly running-max read on resolution day). Historical base rates come from NOAA NCEI GHCND stations (10-year lookback).
The EdgeCalculator uses Abramowitz-Stegun Normal CDF approximation. It calculates a weighted consensus temperature (ECMWF 35%, GFS 25%, UKMO 20%, NWS 20% — for Hong Kong, HKO leads at 50% and tapers by lead time), determines dynamic σ based on hours until resolution (0.8° at <6h up to 5.5° at 10d+), and computes P(outcome) using CDF for ranges, "or higher", and "or lower" market types. Edge = forecast probability − market implied probability. Bayesian blending with NCEI historical data narrows σ when models and history agree. On Hong Kong resolution day, the live HKO running max can lock an outcome outright — the bot buys that near-certain line directly.
WeatherBot uses Kelly criterion: f* = edge / implied_odds, then applies quarter-Kelly (multiply by 0.25) for safety. Maximum fraction is capped at 15% of bankroll per trade. The final trade amount is the minimum of (bankroll × kellyFraction) and your configured maxPerTrade setting. Default bankroll is $500 with $50 max per trade.
All trades execute on Polygon (chain ID 137) via Polymarket's CLOB at clob.polymarket.com. The bot uses USDC (0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174) for trading, and auto-approves the Exchange (0x4bFb41d5), NegRiskExchange (0xC5d563A3), and NegRiskAdapter (0xd91E80cF) contracts on first connect using ethers.js and viem.
The StreamEngine monitors 5 exit conditions on every price tick: (1) Profit target — captured 60%+ of the original edge, (2) Edge converged — market price within 2% of forecast probability, (3) Trailing stop — gave back 40%+ from peak unrealized profit, (4) Stop loss — position down 15%+ from entry, (5) Time decay — within 2 hours of resolution with any profit. When triggered, auto-sells via CLOB.
This is one of the most common issues new users run into. Here's a checklist of things to verify before assuming something is broken:

1. Connect your wallet first — The bot cannot trade without a connected wallet. Head to the Settings page and make sure you've connected your Polygon wallet before starting the bot.

2. Be patient — weather markets are slow — Unlike high-frequency crypto markets, weather markets can be quiet. It may take up to 20 minutes for the bot to detect a tradeable edge. On the flip side, when conditions align, it's not unusual to see 10+ trades fire within a couple of minutes.

3. Double-check your proxy address — Make sure the proxy (funder) address you entered during wallet connection is correct. An incorrect proxy address will prevent trades from executing on-chain.

4. Review your wallet configuration — Go to Settings and confirm your bankroll, maxPerTrade, and minEdge values make sense. Also verify that your wallet has enough USDC balance to cover the trade sizes you've configured.

5. You need POL tokens for gas — This is the most commonly overlooked step. Every trade requires a small amount of POL (Polygon's native token) to pay for gas fees. Even $1 worth of POL in your wallet (MetaMask or whichever wallet you use) is more than enough to cover many trades.
Yes and no. WeatherBot itself is free to use — there's no subscription or upfront cost. However, a small fee is charged per trade, and you get to choose the pricing model that works best for you: either $0.015 per trade (charged on every executed trade regardless of outcome), or $0.03 per winning trade (you only pay when the bot makes you money). Pick whichever option suits your trading style.
No — we don't guarantee profits and no legitimate trading tool ever should. That said, WeatherBot is actively maintained and updated around the clock with new features and improvements. Our internal testing has shown strong results, with profit margins typically ranging between 18% and 48% within a 24-hour period. Don't expect instant returns — weather markets take time to resolve, and outcomes can vary depending on market conditions and a bit of luck. Always trade with funds you can afford to risk.
Yes — you should exit all pre-existing positions before starting the bot. Here's why: WeatherBot's exit engine only manages positions that the bot itself opened. When the bot places a trade, it records the exact entry price, the amount spent, the signal (BUY_YES / BUY_NO), the market ID, and the timestamp — so it can calculate real PnL and trigger exits accurately.

The problem with pre-existing positions (ones you opened manually or through another tool) is that the bot didn't place those trades, so it has no record of your actual entry price. It would have to guess from historical data, which leads to incorrect PnL calculations and false exit triggers — potentially selling your positions at the wrong time.

Since WeatherBot doesn't store any data between sessions, here's how it works:

Bot-opened positions — fully managed by the exit engine with exact entry data, proper PnL tracking, and automated exits.

Pre-existing positions — displayed in the Open Positions panel for your reference, but the bot will not auto-sell them.

To avoid any confusion, close out your existing weather market positions before hitting Start Bot.
If you're coming in expecting to get rich overnight, this bot probably isn't for you — and that's an important thing to understand upfront. Weather markets are fundamentally different from fast-moving crypto or stock markets. They're slower by nature: most trades won't show a result for 24 to 48 hours because markets need to wait for the actual weather to happen before they resolve.

That said, the profits are real — they just take patience. WeatherBot is designed for consistent, edge-based returns over time, not quick flips. Think of it more like a steady compounding engine than a lottery ticket.

Will it make you rich? That depends on your bankroll, your settings, how long you run it, and the market conditions. What we can say is that if you approach it with realistic expectations and let the bot do its job, the results tend to speak for themselves over time.
WeatherBot is under active development — our team works around the clock, pushing updates, new features, and improvements almost every single day. This isn't a "set it and forget it" project — it's constantly evolving.

Right now, we're working on expanding the bot's trading strategies and testing with next-generation AI models including GPT-5, Gemini 3.1, and DeepSeek R2. The goal is to give you the ability to choose between different AI engines depending on what you prioritize — whether that's stronger analytical performance, faster reasoning, or more conservative decision-making.

We have a packed roadmap of exciting features in the pipeline, and we're shipping fast.

If you've found WeatherBot already, consider yourself early — we haven't launched any major marketing campaign yet. You're here before the crowd.

Have a question that's not listed here?

Submit your question and we'll get back to you — or add it to the FAQ if others are asking the same thing.

Check the address before you log in The official site is weatherbot.fi. Beware of look-alike scam domains. Check the address before you log in 🔒 https://weatherbot.fi ✔ This is the official website ⚠ Beware of scams and fake websites Examples of scam domains: ✖ weatherbot.ai ✖ polyweatherbot.fi ✖ weatherbot.io Always type the address manually: weatherbot.fi

Start Weather Trading
on Polymarket Today

Connect your Polygon wallet, fund with USDC, and let Claude AI + 5 weather models find the edge.

Launch WeatherBot

Live Dashboard

WeatherBot Stats

Real-time performance metrics from /api/state. The polymarket weather trading bot exposes all internal state via its Express API — markets, forecasts, signals, AI analyses, streaming stats, open positions, and trade history.

API Endpoints

14
REST routes: /api/state, /api/scan, /api/trade, /api/bot/start, /api/bot/stop, /api/wallet/connect, /api/ai/analyze, /api/ai/analyze-top, /api/traders, and more

Weather Models

5
GFS (NOAA), ECMWF (European), UKMO (UK Met), NWS (US), and HKO (Hong Kong Observatory, HK resolution source) — fetched in parallel via Promise.all()

Cities Supported

67
NYC, London, Tokyo, Paris, Berlin, Seoul, Dubai, Sydney, Mumbai, Istanbul, São Paulo, and 56 more with lat/lon/unit mapping

Top Traders Tracked

10
Leaderboard wallets fetched from data-api.polymarket.com — PnL, win rate, positions, activity, cumulative chart

Edge Threshold

3-8%
Dynamic: max(0.03, min(0.08, σ × 0.02)) — tighter when forecast is confident, wider when uncertain

Forecast Refresh

30 min
Background interval re-fetches all weather APIs and reloads StreamEngine with fresh data

AI Analysis Cycle

5-15 min
Claude Sonnet re-analyzes top 15 markets with full forecast + trade history context to avoid churning

Historical Lookback

10 years
NOAA NCEI GHCND station data for same calendar date — provides Bayesian prior (avg, std, min, max)

Engine Modules

WeatherBot Engines

The polymarket weather trading bot is built from 6 modular engine files, each handling a specific part of the pipeline. All are ES modules running on Node.js with zero external UI frameworks.

StreamEngine stream.js

Real-time WebSocket connection to wss://ws-subscriptions-clob.polymarket.com/ws/market. Subscribes to all weather token IDs, handles price_change, last_trade_price, and book events. On every tick: recalculates edge via inline Normal CDF, checks 5 exit conditions on open positions, and fires trade signals. 30s ping keepalive with auto-reconnect on close.

Core WebSocket

AIAnalyzer ai.js

Sends each market to Claude Sonnet with full context: question, YES/NO prices, GFS/ECMWF/UKMO/NWS forecasts, consensus temp, model agreement, hours until resolution, historical data, edge analysis, and recent trade history (to avoid churning). Returns structured JSON: decision, outcome label, confidence tier, reasoning, edge_pct, risk_notes, and suggested_size_pct.

Core Claude API

EdgeCalculator edge.js

Production probability engine. calculateSigma() maps forecast horizon to uncertainty (0.8° to 5.5°). calculateConsensus() does weighted blending with outlier detection. calculate() runs Normal CDF for each outcome type (exact, range, "or higher", "or lower"), applies Bayesian historical blending, and outputs edge, signal, confidence, Kelly fraction, and expected value.

Core Math

ForecastEngine forecast.js

Fetches from up to 6 real sources: GFS via Open-Meteo (16-day hourly), ECMWF via Open-Meteo (10-day), UKMO via Open-Meteo (7-day), NWS via api.weather.gov (US-only hourly + alerts), HKO via the Hong Kong Observatory Open Data API (Hong Kong only — 9-day forecast + live running max, the official resolution gauge), and NOAA NCEI CDO (10-year historical TMAX at nearest GHCND station). All fetched in parallel. Extracts max temp per target date from hourly arrays.

Core Weather API

Trader trader.js

Connects to Polymarket CLOB via @polymarket/clob-client with ethers.js wallet. Derives API keys, auto-approves USDC and CTF tokens on Exchange, NegRiskExchange, and NegRiskAdapter contracts. Executes FOK market orders first; falls back to GTC limit orders with 2% slippage on signature errors. Tracks dead orderbooks to skip them.

Core Polygon

MarketDiscovery markets.js

Queries Polymarket Gamma API for weather-tagged events (up to 400 via pagination). Falls back to keyword search: "highest temperature", "precipitation weather", "hurricane tornado storm". Parses market titles to extract city (67-city map), date (4 regex patterns), temp unit, and market type. Parses outcomes into ranges, thresholds, and exact values.

Core Gamma API

Documentation

WeatherBot Docs

Complete technical documentation for the WeatherBot polymarket weather trading bot. Setup, API endpoints, configuration, and the full trading pipeline.

Quick Start

git clone <repo>
cd weatherbot
npm install          # installs: express, ethers, @polymarket/clob-client, viem, ws, @anthropic-ai/sdk
npm start            # starts Express server on port 3777
# Open http://localhost:3777 in your browser

Environment Variables

ANTHROPIC_API_KEY=sk-ant-...    # Claude API key for AI analysis
NOAA_CDO_TOKEN=XRHLdkB...      # NOAA CDO token for historical data
PORT=3777                        # Server port (default 3777)

API Endpoints

MethodRouteDescription
GET/api/stateFull bot state: markets, signals, logs, streaming stats, AI analyses, open positions, config
POST/api/scanTrigger market discovery + forecast fetch + edge calculation
POST/api/wallet/connectConnect Polygon wallet with privateKey + proxyAddress. Auto-approves USDC + CTF tokens
POST/api/wallet/disconnectDisconnect wallet and clear credentials from Store
POST/api/tradeExecute a trade: tokenId, side (BUY/SELL), amount, negRisk, tickSize, kellyFraction
POST/api/bot/startStart full pipeline: scan → stream → AI cycle → auto-trade
POST/api/bot/stopStop streaming, clear timers, disconnect WebSocket
POST/api/configUpdate: bankroll, maxPerTrade, minEdge, autoExecute, aggressiveMode, anthropicApiKey
POST/api/ai/analyzeAnalyze single market with Claude (pass marketId)
POST/api/ai/analyze-topBatch analyze top N markets (default 15)
POST/api/aggressiveToggle aggressive mode (lower edge threshold, wider price range)
GET/api/ai/resultsGet latest AI analyses array
GET/api/tradersFetch top 10 weather trader leaderboard with PnL, positions, activity

Configuration Options

SettingDefaultDescription
bankroll$500Total capital available for trading. Kelly fractions are calculated against this
maxPerTrade$50Maximum single trade size. Capped at bankroll
minEdge5%Minimum absolute edge required to generate a signal
autoExecutetrueAuto-execute trades when edge detected or AI recommends
aggressiveModefalseLower thresholds: 3% min edge, BUY_NO allowed above 11¢, MEDIUM confidence trades accepted
scanIntervalSec300Seconds between background market rescans

Market Parsing

The MarketDiscovery module parses Polymarket questions like "What will be the highest temperature in New York on March 15?" into structured data: city (lat/lon from 67-city map), date (4 regex patterns: "on Month Day", "on Day Month", "Month Day", "Day Month Year"), temperature unit (°F for US cities, °C for international), and market type (max_temp, min_temp, precipitation, snow, severe).

Outcomes like "52-53°F", "54°F or higher", "50°F or lower" are parsed into ranges with low/high values, isOrHigher, isOrLower, and isRange flags — enabling the EdgeCalculator to run the correct CDF calculation for each outcome type.

Multi-User Architecture

The Store module (store.js) provides persistent JSON file storage in /data/users.json. Each user gets: credentials (pbkdf2 hashed password, auth token), wallet config (encrypted PK, proxy address), trading config (bankroll, maxPerTrade, minEdge), stats (scans, trades, edgesDetected), AI analyses, trade history, and logs. The BotManager module runs separate StreamEngine + Trader + AI cycle per user while sharing market data across all users.

Top Traders

Weather Trader Leaderboard

WeatherBot tracks the top 10 weather traders on Polymarket via the /api/traders endpoint. Data sourced from data-api.polymarket.com leaderboard, gamma-api.polymarket.com profiles, and positions/activity APIs.

How Trader Tracking Works

The /api/traders endpoint fetches 4 data sources per wallet in parallel: the Polymarket leaderboard API (authoritative PnL + volume), Gamma profile API (username, avatar), positions API (all resolved + active positions with cashPnL), and activity API (last 30 trades). Results are sorted by total PnL descending.

Tracked Wallets

WeatherBot monitors 10 top-performing weather trading wallets defined in cities.js. These are the most profitable weather market participants on Polymarket, identified by cumulative PnL and win rate across weather prediction markets.

Data Points Per Trader

  • Profile — username, profile picture (from leaderboard or Gamma)
  • PnL — total profit/loss from leaderboard API (authoritative source)
  • Volume — total trading volume in USD
  • Win Rate — calculated from positions: (winning positions / total positions) × 100
  • Active Positions — current open positions with size > 0
  • PnL History — cumulative chart built from sorted resolved positions with endDate
  • Recent Trades — last 5 trades with market title, side, size, price, timestamp

AI-Powered Copy Trading

When the bot runs in auto-execute mode, Claude AI analyzes the same markets these top traders are active in. The AI receives full forecast data, edge analysis, and recent trade history — including information about whether the bot already holds a position (to avoid double-entering). This creates an AI-augmented copy trading system where your trades are informed by both the top traders' activity and Claude's independent meteorological analysis.

Anti-Churn Protection

The AI prompt includes recent bot trade history for each market. Claude is instructed to SKIP if the bot just sold for profit and the price hasn't moved, be cautious about re-entering after a loss unless conditions changed, and avoid buying/selling the same outcome repeatedly (which wastes money on spread).

Technical Deep-Dive

WeatherBot Whitepaper

Complete technical specification of the WeatherBot polymarket weather trading bot — probability engine, consensus algorithm, sigma dynamics, Bayesian blending, and Kelly criterion implementation.

1. Consensus Temperature Algorithm

The EdgeCalculator.calculateConsensus() function computes a quality-weighted forecast temperature from up to 4 models. Base weights: ECMWF 0.35 (best global model), GFS 0.25, UKMO 0.20, NWS 0.20. Outlier penalization: if a model's forecast deviates more than 1.5× the standard deviation from the raw mean, its weight is halved. The final consensus is the weighted average of adjusted weights normalized to sum to 1.0.

Model agreement is scored in 5 tiers based on inter-model standard deviation: VERY_HIGH (<0.5°), HIGH (<1.0°), MODERATE (<2.0°), LOW (<3.5°), VERY_LOW (≥3.5°). This agreement score directly affects confidence tiers and can downgrade VERY_HIGH confidence to HIGH when models disagree.

2. Dynamic Sigma (σ) Calculation

Forecast uncertainty σ is the most critical parameter. calculateSigma() takes three inputs: hours until resolution, array of model temperatures, and model count. Base σ from forecast horizon: 0.8° (≤6h), 1.0° (≤12h), 1.3° (≤24h), 1.8° (≤48h), 2.2° (≤72h), 3.0° (≤120h), 3.8° (≤168h), 4.5° (≤240h), 5.5° (beyond). Model count penalty: 1.0× (≥4 models), 1.1× (3), 1.25× (2), 1.5× (1). Spread penalty: 1.0 + (stdDev / 5.0). Final σ is clamped to [0.5, 8.0].

3. Bayesian Historical Blending

When NOAA NCEI historical data is available, the forecast is Bayesian-combined with the 10-year historical distribution for the same calendar date. Combined using precision weighting: combined_precision = forecast_precision + historical_precision, where precision = 1/σ². If forecast and history disagree by more than 1.5 × historical_σ, the combined σ is widened by 30% to account for unusual conditions.

4. Probability Calculation

For each market outcome, the Normal CDF (Abramowitz-Stegun approximation) calculates the probability that the actual temperature falls within the outcome's range:

  • Exact value (e.g., "52°F"): P = CDF(52.5) − CDF(51.5) using ±0.5° bin
  • Range (e.g., "52-53°F"): P = CDF(53.5) − CDF(51.5)
  • "or higher" (e.g., "54°F+"): P = 1 − CDF(54)
  • "or lower" (e.g., "50°F−"): P = CDF(50)

Edge = forecastProb − marketPrice. Trades are signaled when |edge| exceeds the dynamic threshold: max(0.03, min(0.08, σ × 0.02)).

5. Kelly Criterion Sizing

For BUY_YES: kellyFraction = edge / ((1/marketPrice) − 1). For BUY_NO: kellyFraction = |edge| / ((1/noPrice) − 1). Quarter-Kelly is applied (×0.25) and clamped to [0, 0.15]. This means the bot never risks more than 15% of bankroll on a single trade, and typical positions are 1-5% of bankroll.

6. Trade Execution

The Trader class connects to Polymarket's CLOB using @polymarket/clob-client with signature type 2 (POLY_GNOSIS_SAFE). Primary execution: FOK (Fill-Or-Kill) market order for immediate fills. Fallback: GTC limit order at best ask/bid + 2% slippage, rounded to tick size. Dead orderbooks (404/not found) are cached and skipped. Concurrent execution on the same tokenId is prevented via a Set lock.

7. Claude AI Prompt Engineering

Each market is analyzed by Claude Sonnet with a structured prompt containing: market question, YES/NO prices (implied probabilities), all 4 model forecasts, consensus temp, model agreement level, hours until resolution, historical averages, edge analysis per outcome, and recent bot trade history for that market. Two rule sets: BALANCED mode (5% min edge, prefer BUY_YES at 5-40¢) and AGGRESSIVE mode (3% min edge, BUY_NO allowed above 11¢). Output is enforced as JSON with exact outcome labels.

Security & Architecture

WeatherBot Security

Technical security architecture of the WeatherBot polymarket weather trading bot. How keys are handled, contracts approved, and the risk management stack.

Wallet & Key Management

WeatherBot handles all wallet operations client-side. Your private key is used locally to derive the wallet address and Polymarket API credentials (key, secret, passphrase) via the ClobClient. Signature type 2 (POLY_GNOSIS_SAFE) is used with the proxy as funder. Private keys never leave your device and are not stored on any server.

Auto-Approved Contracts

ContractAddressApproval Type
USDC (Polygon)0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174ERC20 approve(MAX_UINT256)
CTF (Conditional Tokens)0x4D97DCd97eC945f40cF65F87097ACe5EA0476045ERC1155 setApprovalForAll
Exchange0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982EUSDC + CTF approval
NegRiskExchange0xC5d563A36AE78145C45a50134d48A1215220f80aUSDC + CTF approval
NegRiskAdapter0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296CTF approval only

Balance Monitoring

On wallet connect, the bot checks POL balance (for gas) and USDC balance (on proxy address, for trading) via Polygon RPC (polygon-bor-rpc.publicnode.com). Warnings are displayed if POL < 0.01 or USDC < $1. Before every trade, the bot verifies the trade amount doesn't exceed available USDC balance and tracks balance locally after each fill.

Risk Management Stack

  • Quarter-Kelly sizing — never risks more than 25% of the mathematically optimal bet size
  • 15% max fraction — hard cap on any single position relative to bankroll
  • maxPerTrade cap — configurable dollar limit per trade (default $50)
  • Dead orderbook detection — skips tokens that return 404/not found from CLOB
  • Concurrent execution lock — prevents double-ordering on the same tokenId via Set
  • Price range filter — skips markets where YES price is below 2¢ or above 98¢
  • Time filter — skips markets resolving within 2 hours (too late for meaningful trades)
  • AI anti-churn — Claude receives recent trade history and is instructed to avoid repeat entries
  • 5-layer exit system — profit target, edge convergence, trailing stop, stop loss, time decay

User Authentication

Authentication is handled client-side using your connected wallet. Session management occurs locally in your browser — no credentials or tokens are stored on any remote server.

Disclaimer

WeatherBot is experimental trading software. Trading on Polymarket involves significant risk — you may lose some or all of your investment. Weather forecasts are probabilistic and not guaranteed. The AI analysis is not financial advice. All wallet operations happen client-side — your private keys are never stored on any server. You are responsible for complying with local regulations regarding prediction market trading. Past performance does not guarantee future results.

Legal

Privacy Policy

How the WeatherBot polymarket weather trading bot handles your data, wallet information, and trading activity.

1. Information We Collect

WeatherBot operates entirely client-side. We do not store your private keys, wallet credentials, or personal data on any server. The following data is handled locally in your browser or on your own infrastructure:

  • Wallet Data — Your Polygon wallet address and proxy (funder) address are used client-side for on-chain trade execution via Polymarket's CLOB. Private keys never leave your device.
  • Trading Data — Trade history, AI analyses, open positions, edge detections, and configuration settings (bankroll, maxPerTrade, minEdge) are managed locally.
  • Usage Metrics — Scan counts, trade counts, price update counts, and edge detection counts are tracked locally per session.

2. How We Use Your Data

All collected data is used exclusively to operate the polymarket weather trading bot:

  • Wallet credentials are used to sign and execute trades on Polymarket via the Polygon network.
  • Trading configuration determines position sizing, edge thresholds, and automation behavior.
  • Trade history is passed to Claude AI to prevent churning (repeated buy/sell on the same outcome).
  • Logs and metrics are displayed in the dashboard UI for your monitoring.

3. Data Storage

All data is handled client-side. WeatherBot does not store user data on any remote server or cloud database. There is no third-party analytics and no external data transmission beyond the APIs required for bot operation (listed below).

4. Third-Party Services

WeatherBot communicates with the following external services as part of normal operation:

  • Polymarket — CLOB API (clob.polymarket.com), Gamma API (gamma-api.polymarket.com), WebSocket (ws-subscriptions-clob.polymarket.com), Data API (data-api.polymarket.com) for market discovery, trading, and streaming.
  • Open-Meteo — Weather forecast API (api.open-meteo.com) for GFS, ECMWF, and UKMO model data. No authentication required.
  • NOAA / NWS — US weather forecasts (api.weather.gov) and historical climate data (ncei.noaa.gov). Public APIs.
  • Anthropic — Claude AI API (api.anthropic.com) for market analysis. Your Anthropic API key is used; market data (not personal data) is sent for analysis.
  • Polygon RPC — Public Polygon node (polygon-bor-rpc.publicnode.com) for balance checks and token approvals.

5. Data Retention

Logs are capped at 200 entries per user (oldest are discarded). Trade history is capped at 100 entries. AI analyses are capped at 20. Live edge detections are capped at 50. This data persists until the server data directory is manually cleared.

6. Security

WeatherBot operates client-side — your private keys are never transmitted to or stored on any server. All signing and trade execution happens locally on your device. Users should ensure their device and browser environment are secure.

7. Your Rights

You can disconnect your wallet at any time via the dashboard. Since all data is handled client-side, disconnecting your wallet clears all associated data from your session. No server-side data deletion is required.

8. Changes to This Policy

This privacy policy may be updated as WeatherBot evolves. Changes will be reflected on this page. Continued use of the polymarket weather trading bot after changes constitutes acceptance of the updated policy.

Last updated: March 2026

Legal

Terms of Service

Terms and conditions governing your use of the WeatherBot polymarket weather trading bot.

1. Acceptance of Terms

By accessing or using WeatherBot ("the Service"), you agree to be bound by these Terms of Service. If you do not agree to these terms, do not use the Service. WeatherBot is a polymarket weather trading bot that executes trades on Polymarket prediction markets using automated strategies.

2. Description of Service

WeatherBot is experimental open-source trading software that:

  • Discovers weather prediction markets on Polymarket via the Gamma API
  • Fetches weather forecasts from GFS, ECMWF, UKMO, and NWS weather models
  • Calculates probabilistic edge using Bayesian statistics and Normal CDF approximations
  • Analyzes markets using Anthropic's Claude AI for trading decisions
  • Executes trades on Polymarket's CLOB via the Polygon blockchain
  • Monitors open positions with automated exit conditions

3. Risk Disclosure

Trading on Polymarket involves significant financial risk. You may lose some or all of your invested capital. By using WeatherBot, you acknowledge and accept the following risks:

  • Market Risk — Weather prediction markets are volatile. Prices can move against your positions rapidly and unpredictably.
  • Model Risk — Weather forecasts are probabilistic, not guaranteed. The GFS, ECMWF, UKMO, and NWS models can and do produce incorrect forecasts.
  • AI Risk — Claude AI's trading recommendations are based on pattern matching and reasoning, not certainty. AI can make errors in judgment.
  • Execution Risk — Trades may fail due to insufficient liquidity, network congestion, dead orderbooks, or API errors.
  • Smart Contract Risk — Interacting with Polymarket's smart contracts on Polygon carries inherent blockchain risks including bugs, exploits, and network failures.
  • Software Risk — WeatherBot is experimental software. Bugs, crashes, or unexpected behavior may result in financial losses.

4. No Financial Advice

WeatherBot does not provide financial, investment, or trading advice. The automated signals, AI analyses, edge calculations, and trade executions are algorithmic outputs — not recommendations. You are solely responsible for your trading decisions and their financial consequences. Past performance of the bot, its models, or tracked traders does not guarantee future results.

5. Eligibility

You represent and warrant that:

  • You are of legal age in your jurisdiction to enter into these terms
  • You are not located in a jurisdiction where prediction market trading is prohibited
  • You have read and agree to Polymarket's Terms of Service
  • You understand the risks of cryptocurrency trading and blockchain interactions
  • The funds you use for trading are not derived from illegal activity

6. User Responsibilities

You are responsible for:

  • Securing your device and browser environment where WeatherBot runs
  • Protecting your private key and wallet credentials
  • Monitoring your bot's activity and positions
  • Ensuring adequate POL for gas fees and USDC for trading
  • Configuring appropriate bankroll, maxPerTrade, and minEdge settings for your risk tolerance
  • Complying with all applicable laws and regulations in your jurisdiction

7. Limitation of Liability

WeatherBot is provided "as is" and "as available" without warranties of any kind, express or implied. To the maximum extent permitted by law, the developers of WeatherBot shall not be liable for any direct, indirect, incidental, special, consequential, or punitive damages arising from your use of the Service, including but not limited to financial losses from trades, wallet compromise, smart contract failures, or software bugs.

8. Intellectual Property

WeatherBot's source code, algorithms (including the EdgeCalculator, ForecastEngine, StreamEngine, AIAnalyzer, and Trader modules), documentation, and website design are the intellectual property of the WeatherBot team. The polymarket weather trading bot name and branding are proprietary.

9. Termination

You may stop using WeatherBot at any time by disconnecting your wallet and stopping the bot. We reserve the right to modify, suspend, or discontinue the Service at any time without notice.

10. Modifications

These Terms of Service may be updated at any time. Continued use of the polymarket weather trading bot after modifications constitutes acceptance of the revised terms. Material changes will be noted on this page with an updated date.

11. Governing Law

These terms shall be governed by and construed in accordance with applicable law, without regard to conflict of law principles. Any disputes arising from these terms or your use of WeatherBot shall be resolved through binding arbitration.

12. Contact

For questions about these Terms of Service, please contact us at [email protected].

Last updated: March 2026

What Is a Polymarket Weather Trading Bot?

A Polymarket weather trading bot is an automated trading tool that discovers, analyzes, and executes trades on weather prediction markets hosted on Polymarket — the world's largest decentralized prediction market platform. Instead of manually scanning dozens of weather markets, comparing forecasts, and placing orders by hand, a weather trading bot like WeatherBot handles the entire pipeline: market discovery, forecast aggregation, probability calculation, edge detection, and trade execution — all in real time.

WeatherBot is the leading Polymarket weather trading bot, purpose-built to trade weather prediction markets using a 5-source ensemble of professional-grade weather forecasting APIs (GFS, ECMWF, UKMO, NWS, and — for Hong Kong — the Hong Kong Observatory, the official gauge Polymarket settles HK markets on) combined with Claude AI for intelligent trade decision-making. It connects directly to Polymarket's Central Limit Order Book (CLOB) via WebSocket for sub-second price streaming and executes trades on the Polygon blockchain using USDC.

How to Trade Weather on Polymarket

Weather markets on Polymarket are prediction markets where you bet on weather outcomes — typically the highest temperature in a specific city on a specific date. For example, "Will NYC's highest temperature on March 20th be 52–53°F?" You can buy YES or NO shares, and if the outcome resolves in your favor, you profit.

Trading weather on Polymarket manually requires monitoring dozens of markets across 67+ cities, cross-referencing multiple weather forecast models, calculating implied probabilities from market prices, and timing your entries and exits. WeatherBot automates all of this. The Polymarket weather trading bot scans all active weather markets, fetches real-time forecasts from four independent weather models, blends them with 10-year historical climate data using Bayesian statistics, identifies edges where the market is mispricing an outcome, and executes trades using Kelly criterion position sizing — all without any manual intervention.

Why WeatherBot Is the Best Polymarket Weather Bot

What sets WeatherBot apart from other Polymarket trading bots is its specialization. While generic prediction market bots try to cover every category, WeatherBot focuses exclusively on weather markets — which means every component of the system is optimized for meteorological data. The ensemble weighting (ECMWF at 35%, GFS at 25%, UKMO at 20%, NWS at 20% — and for Hong Kong, the Hong Kong Observatory leading at 50%, since it is the exact gauge the market settles on) with automatic outlier penalization produces more accurate consensus temperatures than any single model alone. Dynamic sigma calculation adjusts forecast uncertainty based on time-to-resolution (from 0.8° at 6 hours to 5.5° at 10+ days), ensuring the bot doesn't overtrade when forecasts are uncertain.

The Bayesian blending with NOAA NCEI historical base rates adds another layer of accuracy — if a forecast diverges significantly from the 10-year historical average for that date and location, the system widens its uncertainty band rather than blindly trusting a potentially anomalous forecast. Combined with Claude AI's reasoning capabilities for the final trade/no-trade decision, and quarter-Kelly position sizing that never risks more than 15% of bankroll on any single trade, WeatherBot is engineered for consistent, risk-managed profitability on Polymarket weather markets.

Polymarket Weather Trading Bot Features

WeatherBot includes real-time WebSocket price streaming from Polymarket's CLOB, 5-source ensemble weather forecasting, Bayesian edge detection with Normal CDF probability, Kelly criterion position sizing with quarter-Kelly safety caps, Claude AI-powered trade analysis, copy trading signals from the top 10 Polymarket weather traders, support for 67+ global cities, a 5-layer automated exit system (profit target, edge convergence, trailing stop, stop loss, and time decay), NOAA NCEI 10-year historical base rate integration, and fully client-side wallet security where your private keys never leave your device.

Supported Cities for Weather Trading on Polymarket

WeatherBot covers all major weather prediction markets on Polymarket with support for 67+ global cities including New York, Los Angeles, Chicago, Miami, Phoenix, Houston, Dallas, Denver, Seattle, San Francisco, Boston, Atlanta, Washington DC, London, Paris, Berlin, Madrid, Rome, Amsterdam, Tokyo, Seoul, Beijing, Shanghai, Mumbai, Delhi, Dubai, Istanbul, Moscow, Sydney, Melbourne, São Paulo, Buenos Aires, Mexico City, Cairo, Lagos, Johannesburg, Toronto, Vancouver, and many more. Each city is mapped with precise latitude/longitude coordinates and correct temperature unit (°F or °C) for accurate forecast retrieval from all four weather models.

☑

How should we structure our pricing going forward?

Help us decide — your vote matters.

113 votes
Pay-per-trade 76% 86 votes Monthly membership 24% 27 votes
Option 1: Pay-per-trade 76%
$0.015 per trade, or $0.03 per winning trade
86 votes
Option 2: Monthly membership 24%
$29.95 per user, billed monthly
27 votes

✓ Thanks for voting!