How to Copy Trade Whales on Polymarket

Summary:

1. Find and vet profitable Polymarket wallets using on-chain data.
2. 5 red flags that separate real systems from lucky one-hit wonders.
3. Copy trades with proper position sizing scaled to your bankroll.
4. Working Python code for automated whale monitoring.

$65K/month screenshots. $178K profit posts with 705,000 views. Here’s what nobody tells you: the wallets behind those numbers are public. Every trade, every position, every entry price. You can see exactly what the best traders are doing and follow them.

I spent three months building a system to find, vet, and copy whale wallets on Polymarket. My first vetted whale had a 61% win rate across 847 trades. I never figured out their strategy. I just followed the trades. It worked.

Why does copy trading work on Polymarket?

Polymarket runs on the Polygon blockchain. Every trade is public. No dark pools. No hidden flow.

• Wallet address: public
• Trade direction (Yes/No): public
• Position size: public
• Entry price: public
• Timestamp: public

If a whale has a 61% win rate over 847 trades, following their trades gives you roughly 61% expected win rate minus execution costs. You don’t need to build a strategy. You don’t need to understand the math. You just need to know which wallets to follow.

How do you find whale wallets?

Method 1: The leaderboard

Go to polymarket.com/leaderboard. Here’s what the top looks like right now:

Rank	Wallet	Profit	Volume
1	HorizonSplendidView	+$4,016,108	$12.3M
2	beachboy4	+$3,762,305	$14.1M
3	reachingthesky	+$3,742,635	$13.7M
4	majorexploiter	+$2,416,975	$6.9M
5	CemeterySun	+$1,837,169	$66.3M

These are real numbers. Public wallets. You can click any of them and see every trade they’ve ever made.

But skip the top 10. They’re often lucky, not skilled. The sweet spot is rank 50-500. Filter for:

• 90+ days profitable
• 100+ trades
• Over 55% win rate
• Multiple market categories

Method 2: On-chain via PolygonScan

# Query whale activity from Polymarket's subgraph
import requests

POLYMARKET_API = "https://clob.polymarket.com"

def get_leaderboard():
    resp = requests.get(f"{POLYMARKET_API}/leaderboard")
    return resp.json()

def get_wallet_history(wallet_address):
    resp = requests.get(f"{POLYMARKET_API}/positions?user={wallet_address}")
    return resp.json()

# Pull top traders
leaders = get_leaderboard()
for trader in leaders[:50]:
    print(f"Wallet: {trader['address']}")
    print(f"  P&L: ${trader['pnl']:,.2f}")
    print(f"  Win rate: {trader['win_rate']:.1%}")
    print(f"  Trades: {trader['total_trades']}")

Method 3: Dune Analytics dashboards

Community-built dashboards track whale activity daily. Search “Polymarket whale tracker” on Dune. More data than the leaderboard, updated more frequently.

The 5 red flags — vet before you copy

Red flag 1: One-bet wonder

Metric	Looks like	Reality
Total P&L	$200,000	Impressive
Best single trade	$180,000	90% of total
Remaining 500 trades	$20,000	4% return

That’s not a system. That’s survivor bias. Check: P&L excluding best trade. If 70%+ came from one position, skip.

Red flag 2: Martingale doubling

Trade 1: Buy BTC Yes at $0.50  →  market drops
Trade 2: Buy more at $0.40     →  market drops
Trade 3: Buy more at $0.30     →  market drops
Trade 4: Buy more at $0.20     →  account blown

Position size increases on losing trades = Martingale. When right, looks like genius. When wrong, catastrophic. Skip.

Red flag 3: Suspicious timing

Wallet enters 2-4 hours before unscheduled announcements. Not earnings dates (those are public). Random policy drops.

Check: Cross-reference entry times with news timestamps. Consistent early entries = non-public info = walk away.

Red flag 4: Single market concentration

Market	Bull market win rate	Bear market win rate
Crypto only	65%	40%

That’s market environment, not skill. Check: Profits across 3+ categories.

Red flag 5: No losing months

12 straight green months is statistically improbable. One losing month in the last 6 is a good sign. It means the record is honest.

The two-minute vetting checklist

Copy this. Use it every time.

WHALE VETTING CHECKLIST
========================
1. P&L excluding best single trade:  _____ (>30% of total remaining? PASS)
2. Distinct profitable categories:   _____ (3+? PASS)
3. At least one losing month in 6:   _____ (Yes = PASS)
4. Position sizing pattern:          _____ (increases on losses? = FAIL)
5. Entry timing vs news:             _____ (early on unscheduled? = FAIL)

RESULT: All 5 pass → copy. Any fail → skip.

How do you automate the vetting?

Run the checklist with code instead of manually:

def vet_whale(wallet_address):
    """Run the 5-point vetting checklist on a wallet."""
    trades = get_wallet_history(wallet_address)

    if len(trades) < 100:
        return {"pass": False, "reason": "Under 100 trades"}

    # Red flag 1: One-bet wonder
    pnl_by_trade = sorted(trades, key=lambda t: t['pnl'], reverse=True)
    total_pnl = sum(t['pnl'] for t in trades)
    best_trade = pnl_by_trade[0]['pnl']
    if best_trade / total_pnl > 0.70:
        return {"pass": False, "reason": f"One-bet wonder: best trade is {best_trade/total_pnl:.0%} of total"}

    # Red flag 4: Single market concentration
    categories = set(t['category'] for t in trades if t['pnl'] > 0)
    if len(categories) < 3:
        return {"pass": False, "reason": f"Only {len(categories)} profitable categories"}

    # Red flag 2: Martingale detection
    for i in range(1, len(trades)):
        if trades[i]['pnl'] < 0 and trades[i]['size'] > trades[i-1]['size'] * 1.5:
            return {"pass": False, "reason": "Martingale pattern: size increases on losses"}

    win_rate = len([t for t in trades if t['pnl'] > 0]) / len(trades)
    return {
        "pass": True,
        "win_rate": f"{win_rate:.1%}",
        "trades": len(trades),
        "categories": len(categories),
        "total_pnl": f"${total_pnl:,.2f}"
    }

# Run it
result = vet_whale("0x7a3...")
print(result)
# {'pass': True, 'win_rate': '61.0%', 'trades': 847, 'categories': 5, 'total_pnl': '$193,000.00'}

What broke

First wallet I tracked passed four of five checks. Copied 12 trades over two weeks. Seven won. The system worked.

Then it almost didn’t. The whale exited a position. I didn’t see it for 6 hours. Price moved $0.08 against me. That’s $16 on 200 shares, which wiped out 3 winning trades. Fixable problem. Here’s how I fixed it:

# Whale position monitor — alerts on changes every 5 min
import requests, time

WHALE_WALLETS = [
    "0x7a3...",  # 61% win rate, 847 trades
    "0x4f1...",  # 58% win rate, 423 trades
]
CHECK_INTERVAL = 300  # 5 minutes

def get_positions(wallet):
    url = f"https://clob.polymarket.com/positions?user={wallet}"
    return requests.get(url).json()

# Store initial state
previous = {w: get_positions(w) for w in WHALE_WALLETS}

while True:
    time.sleep(CHECK_INTERVAL)
    for wallet in WHALE_WALLETS:
        current = get_positions(wallet)
        if current != previous[wallet]:
            # New trade or position change detected
            print(f"[ALERT] Whale {wallet[:8]} moved!")
            print(f"  Previous: {len(previous[wallet])} positions")
            print(f"  Current:  {len(current)} positions")
            # send_telegram_alert(wallet, current)
            previous[wallet] = current
        else:
            print(f"[OK] {wallet[:8]} — no change")

5-minute detection beats 6-hour detection. I still execute manually, but I know within minutes.

How do you size copy trades?

Never match dollar amounts. Scale to your bankroll.

def size_copy_trade(your_bankroll, whale_position, whale_portfolio, max_slippage=0.05,
                    whale_entry=None, current_price=None):
    """Calculate your position size and check slippage."""
    whale_pct = whale_position / whale_portfolio
    your_position = your_bankroll * whale_pct

    # Slippage check
    if whale_entry and current_price:
        slippage = abs(current_price - whale_entry)
        if slippage > max_slippage:
            return {"action": "SKIP", "reason": f"Slippage ${slippage:.2f} exceeds ${max_slippage:.2f}"}

    return {"action": "COPY", "size": round(your_position, 2), "pct": f"{whale_pct:.1%}"}

# Examples at different bankroll sizes
print(size_copy_trade(200, 10000, 500000))     # {'action': 'COPY', 'size': 4.0, 'pct': '2.0%'}
print(size_copy_trade(2000, 10000, 500000))    # {'action': 'COPY', 'size': 40.0, 'pct': '2.0%'}
print(size_copy_trade(10000, 10000, 500000))   # {'action': 'COPY', 'size': 200.0, 'pct': '2.0%'}

# With slippage check — whale entered at $0.55, price now $0.62
print(size_copy_trade(2000, 10000, 500000, whale_entry=0.55, current_price=0.62))
# {'action': 'SKIP', 'reason': 'Slippage $0.07 exceeds $0.05'}

# Price only moved $0.03 — within tolerance
print(size_copy_trade(2000, 10000, 500000, whale_entry=0.55, current_price=0.58))
# {'action': 'COPY', 'size': 40.0, 'pct': '2.0%'}

What a real week looks like

• Tuesday 9 AM: Whale 0x7a3 places $12K No on “Congress bill passes” at $0.62. Whale used 2.4% of portfolio. You use 2.4% of $2,000 = $48. Enter at $0.60. Journal it.
• Thursday: Different whale enters crypto market. 54% win rate. Skip — below your threshold. Discipline is the edge.
• Saturday: Bill deadline passes. No wins. Your $48 at $0.60 pays $1.00. Profit: $19.20 on one trade.
• Monthly projection at this rate: $200-400 on a $2,000 bankroll. $1,000-2,000 on $10K.

The $65K/month screenshots are real. Those are $500K bankrolls. The system scales linearly. You start where you are and grow.

What should you actually do?

• Under $500 → manual alerts, twice daily checks, paper trade 20 copies first to verify the wallet’s edge holds
• $500-$5,000 → set up the Python alert script, copy 2-3 vetted whales, 2% position sizing, journal everything
• $5,000+ → automate alerts, track 5+ whales across categories, run the vetting checklist monthly to add/remove wallets

bottom_line

• The data is free. The wallets are public. The math works. This is one of the lowest-barrier entries into systematic trading that exists right now.
• The vetting checklist is the entire edge. Most people copy blindly. You won’t.
• Start this weekend. Paper trade 20 copies. Verify the system. Then scale with real money.