How to Build a Polymarket Copy Trading Bot

Copy trading lets you mirror the trades of profitable Polymarket whales automatically. This tutorial covers the best tools (Stand.trade, Polycule), how to find traders worth following, and how to build your own copy trading bot with Python.

Copy Trading Platforms

Stand.trade (Free)

Stand.trade is a free advanced trading terminal for tracking and copying Polymarket whales.

• Follow and copy traders with one click via Discovery tab
• Real-time feeds combining whale trades and activity
• Discord DMs for trade alerts
• Quick fills with order books and position details
• Price: Free

Polycule (Telegram)

The most popular automated copy trading bot, operating via Telegram:

• Automatic execution: Mirrors trades when followed traders act
• Position sizing: Fixed amount, percentage, or percentage with limits
• Filters: Market duration, liquidity, volume, odds thresholds
• Sell config: Proportional, fixed, or custom percentage
• Price: 1% fee (reduced with PCULE tokens)

Other Tools

Finding Traders to Copy

Performance Metrics to Evaluate

Where to Find Top Traders

• Polymarket Leaderboard: polymarket.com/leaderboard (basic)
• Polymarket Analytics: polymarketanalytics.com/traders (detailed)
• Predicting.top: Cross-platform leaderboard (Poly + Kalshi)
• PolyTrack: Advanced filtering by category, win rate, ROI

Notable Top Traders

See What Whales Are Trading Right Now

Get instant alerts when top traders make moves. Track P&L, win rates, and copy winning strategies.

Free forever. No credit card required.

How Copy Trading Works

The Execution Flow

1. Monitor: Bot scans target wallet positions (every ~4 seconds)
2. Analyze: Compares target vs your current positions
3. Execute: Places buy/sell orders to match allocation
4. Manage: Applies position limits (e.g., max 20% per market)

Position Sizing Strategies

• Proportional: Copy 10% of whale's position size ($100 whale = $10 you)
• Fixed amount: Always bet $25 regardless of whale size
• Tiered: Different multipliers for different traders

Multi-Trader Strategy

One trader reported making $10K+/month by watching for consensus:

"When multiple big traders I follow all move in the same direction on a market, I jump in. Consensus from top traders is a strong signal."

Build Your Own Copy Trading Bot

Architecture

# Bot Architecture
1. Data Collector    - WebSocket for real-time trade data
2. Strategy Engine   - Analyze signals, generate copy decisions
3. Order Manager     - Place and track orders
4. Risk Manager      - Position limits, stop-losses
5. Logger           - Record trades for analysis

Basic Setup with py-clob-client

from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs, MarketOrderArgs, OrderType
from py_clob_client.order_builder.constants import BUY, SELL

HOST = "https://clob.polymarket.com"
CHAIN_ID = 137

# Initialize client
client = ClobClient(
    HOST,
    key="YOUR_PRIVATE_KEY",
    chain_id=CHAIN_ID,
    signature_type=1,  # 1 for email/Magic wallet
    funder="YOUR_FUNDER_ADDRESS"
)
client.set_api_creds(client.create_or_derive_api_creds())

Execute Copy Trade

def copy_trade(token_id, side, amount, copy_ratio=0.1):
    """
    Copy a whale trade with configurable ratio.

    copy_ratio=0.1 means copy 10% of whale's position
    """
    copy_amount = amount * copy_ratio

    # Use market order for immediate execution
    market_order = MarketOrderArgs(
        token_id=token_id,
        amount=copy_amount,
        side=side,
        order_type=OrderType.FOK  # Fill-or-Kill
    )

    signed = client.create_market_order(market_order)
    result = client.post_order(signed, OrderType.FOK)
    return result

# Example: Copy a $1000 YES trade at 10%
copy_trade(
    token_id="TOKEN_ID_HERE",
    side=BUY,
    amount=1000,
    copy_ratio=0.1  # You bet $100
)

Monitor Whale Wallets

import time

WHALE_WALLETS = [
    "0xWhale1Address...",
    "0xWhale2Address...",
]

def monitor_whales():
    """Poll whale positions and detect new trades."""
    previous_positions = {}

    while True:
        for wallet in WHALE_WALLETS:
            # Query positions from subgraph
            current = get_wallet_positions(wallet)

            if wallet in previous_positions:
                # Detect new/changed positions
                for market, pos in current.items():
                    old = previous_positions[wallet].get(market, {})
                    if pos['balance'] > old.get('balance', 0):
                        # Whale increased position - copy!
                        print(f"Whale {wallet} buying {market}")
                        copy_trade(
                            token_id=pos['token_id'],
                            side=BUY,
                            amount=pos['balance'] - old.get('balance', 0)
                        )

            previous_positions[wallet] = current

        time.sleep(4)  # Check every 4 seconds

Risks and Considerations

Front-Running

• All Polymarket trades are visible on-chain
• Top traders view this as "edge leak"
• Multiple copy traders competing moves price before you execute
• Some whales use secondary wallets to avoid detection

Slippage

• Delay between whale trade and your copy = worse price
• Particularly bad in illiquid markets
• Multiple copy traders executing simultaneously compounds slippage
• Mitigation: Use liquidity filters, set slippage limits

Wash Trading Warning

Capital Requirements

• No minimum, but practical minimum: $1,000+
• Profitable traders make $1K+ positions
• Copying at 10% scale requires $100+ per trade
• Multiple positions require larger capital base

Profitability Reality Check

Open Source Repos

• Trust412/polymarket-copy-trading-bot-v1: Basic copy trading
• Trust412/polymarket-copy-trading-bot-version-3: Safe Wallet + MongoDB
• Polymarket-copy-trader/polymarket-copy-trading-bot: TypeScript, multi-trader
• Polymarket/agents: Official AI agent framework

Best Practices

1. Follow 5-10 traders across different specializations
2. Use category leaderboards to find niche experts
3. Set up real-time alerts to minimize execution delay
4. Consider "fading" (counter-trading) historically losing accounts
5. Start with small positions until you validate the strategy
6. Monitor for consensus—multiple whales moving together is a stronger signal