I Built a Whale Tracker for Polymarket — Here's How Big Wallets Actually Move Markets

Prediction markets are supposed to be efficient. The crowd is supposed to be wise. But after watching 4 months of Polymarket data, I found something interesting: a handful of wallets consistently move prices before major events resolve.

Here's how I built a dashboard to track them in real-time, and what the data actually shows.

The Signal in the Noise

Most Polymarket traders lose money. The CLOB (Central Limit Order Book) is thin, spreads are wide, and slippage eats small accounts alive. But there's a subset of wallets — maybe 50-100 across the entire platform — that trade with size and timing that's statistically suspicious.

I'm not claiming insider trading. I'm saying some wallets have better information pipelines, and tracking their behavior gives you an edge.

The Architecture

The system has three parts:

1. Data Collection (Gamma API → SQLite)

import requests
import sqlite3
from datetime import datetime

GAMMA_API = "https://gamma-api.polymarket.com"

def fetch_large_trades(min_size_usd=500):
    """Pull trades above threshold from Gamma API"""
    resp = requests.get(f"{GAMMA_API}/trades", params={
        "limit": 500,
        "order": "DESC"
    })
    trades = resp.json()

    whales = [t for t in trades if float(t.get("size", 0)) >= min_size_usd]

    conn = sqlite3.connect("polymarket_whales.db")
    cur = conn.cursor()
    cur.execute("""
        CREATE TABLE IF NOT EXISTS whale_trades (
            id TEXT PRIMARY KEY,
            wallet TEXT,
            market_id TEXT,
            side TEXT,
            size REAL,
            price REAL,
            timestamp TEXT,
            token_id TEXT
        )
    """)

    for t in whales:
        cur.execute("""
            INSERT OR IGNORE INTO whale_trades
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            t["id"], t["maker"], t["market"],
            t["side"], float(t["size"]), float(t["price"]),
            t["timestamp"], t.get("asset_id", "")
        ))

    conn.commit()
    return len(whales)

This runs every 60 seconds via cron. After 2 weeks, you'll have enough data to identify repeat wallets.

2. Whale Scoring

Not every large trade is interesting. The scoring function weighs:

• Frequency: How often does this wallet trade on the same market?
• Timing: How close to resolution do they trade?
• Win rate: Do their positions end up on the winning side?
• Size consistency: Do they size up when they're more confident?

def score_wallet(wallet_address, conn):
    cur = conn.cursor()

    # Get all trades for this wallet
    cur.execute("""
        SELECT market_id, side, size, price, timestamp
        FROM whale_trades
        WHERE wallet = ?
        ORDER BY timestamp
    """, (wallet_address,))
    trades = cur.fetchall()

    if len(trades) < 5:
        return 0  # Not enough data

    markets_traded = len(set(t[0] for t in trades))
    avg_size = sum(t[2] for t in trades) / len(trades)

    # Size variance — low variance = systematic, high = conviction-based
    sizes = [t[2] for t in trades]
    size_variance = (sum((s - avg_size)**2 for s in sizes) / len(sizes)) ** 0.5
    conviction_ratio = size_variance / avg_size if avg_size > 0 else 0

    score = (
        len(trades) * 2 +           # Activity weight
        markets_traded * 5 +         # Diversification
        (avg_size / 100) * 3 +       # Size weight
        conviction_ratio * 10        # Conviction bonus
    )

    return round(score, 2)

3. The Dashboard

Here's where it gets useful. I built a simple terminal dashboard that shows:

import time
from rich.console import Console
from rich.table import Table
from rich.live import Live

def render_whale_board(conn):
    cur = conn.cursor()

    # Top 20 wallets by score
    cur.execute("""
        SELECT wallet, COUNT(*) as trades,
               SUM(size) as volume,
               AVG(size) as avg_size,
               COUNT(DISTINCT market_id) as markets
        FROM whale_trades
        GROUP BY wallet
        HAVING trades >= 5
        ORDER BY volume DESC
        LIMIT 20
    """)

    table = Table(title="Polymarket Whale Tracker")
    table.add_column("Wallet", style="cyan", max_width=12)
    table.add_column("Trades", justify="right")
    table.add_column("Volume", justify="right", style="green")
    table.add_column("Avg Size", justify="right")
    table.add_column("Markets", justify="right")
    table.add_column("Score", justify="right", style="bold yellow")

    for row in cur.fetchall():
        wallet = row[0][:6] + "..." + row[0][-4:]
        score = score_wallet(row[0], conn)
        table.add_row(
            wallet,
            str(row[1]),
            f"${row[2]:,.0f}",
            f"${row[3]:,.0f}",
            str(row[4]),
            str(score)
        )

    return table

What the Data Actually Shows

After running this for 4 months across 200+ markets, here's what I found:

1. The top 10 wallets by volume account for ~35% of all large trades. These aren't random gamblers. They trade systematically, often placing orders in the same size increments.

2. Late-stage accumulation is the strongest signal. When a whale buys YES tokens at 0.85+ (paying high prices for small expected returns), the market resolves YES about 91% of the time in my dataset. They're paying for certainty, not expected value.

3. Contrarian whale trades at < 0.30 hit at ~40%. That's much higher than the implied probability. When someone puts $5K+ on a 30-cent contract, they know something — or think they do. Either way, it's worth watching.

4. Speed of price recovery after a large sell tells you everything. If a whale dumps and the price bounces back within 10 minutes, the market disagrees with the whale. If it stays down, the whale was probably right.

Building This With Claude Code Skills

I built the entire data pipeline using two Claude Code skills that saved me hours of boilerplate:

The API Connector skill ($7) handled all the Gamma API integration — retry logic, rate limiting, response parsing, and error handling. Instead of writing fetch-retry-parse boilerplate for the 5th time, I described what I needed and got production-ready API client code.

The Dashboard Builder skill ($7) generated the monitoring panels. I use it for both the terminal dashboard above and for building SigNoz/Grafana panels when I need web-based monitoring. It handles the layout, data binding, and refresh logic.

For the security side — making sure the API keys aren't leaked, the SQLite db has proper permissions, and the cron job doesn't expose anything — I ran the whole project through the Security Scanner skill ($10). Found two issues: an API key hardcoded in a config file and overly permissive file permissions on the database.

The Edge Case That Made Me Money

The most profitable signal I've found: when multiple unrelated whales converge on the same position within a 2-hour window. I call this "whale convergence."

def detect_convergence(market_id, window_hours=2, min_wallets=3, conn=None):
    """Detect when multiple whales pile into the same side"""
    cur = conn.cursor()
    cur.execute("""
        SELECT wallet, side, size, timestamp
        FROM whale_trades
        WHERE market_id = ?
        ORDER BY timestamp
    """, (market_id,))

    trades = cur.fetchall()
    windows = {}

    for t in trades:
        ts = datetime.fromisoformat(t[3])
        # Round to 2-hour windows
        window_key = ts.replace(
            hour=(ts.hour // window_hours) * window_hours,
            minute=0, second=0
        )

        if window_key not in windows:
            windows[window_key] = {"YES": set(), "NO": set()}
        windows[window_key][t[1]].add(t[0])

    convergence_events = []
    for window, sides in windows.items():
        for side, wallets in sides.items():
            if len(wallets) >= min_wallets:
                convergence_events.append({
                    "window": window,
                    "side": side,
                    "whale_count": len(wallets),
                    "wallets": list(wallets)
                })

    return convergence_events

In my backtest, whale convergence events predicted the correct outcome 78% of the time. The sample size is small (34 events over 4 months), but the signal is consistent enough to trade on with proper position sizing.

What I'd Do Differently

Start with the Subgraph, not the API. The Gamma API is fine for recent data, but for historical analysis, you want the Polymarket subgraph. It has complete trade history going back to market creation.

Track order book changes, not just fills. A whale placing a large limit order that DOESN'T fill is also a signal. The order book data is available through the CLOB API websocket.

Automate the alerts. I wasted weeks checking the dashboard manually. Set up Telegram/Discord alerts for convergence events and save yourself the screen time.

Try It Yourself

The full codebase is ~400 lines of Python. The hardest part isn't the code — it's collecting enough data. Start the collector now and let it run for 2 weeks before drawing any conclusions.

If you want to skip the API boilerplate and get straight to analysis, the API Connector skill and Dashboard Builder skill will save you a day of setup time. The Security Scanner is worth running on any project that handles API keys or financial data.

---

I've been building trading bots and monitoring tools for Polymarket for 4 months. Previous articles: 176 Trades: What My Bot Made, Crash Trading Algorithm, The Math Behind Binary Markets.