Copy Trade Bot Polymarket - How the Mechanics Work

A copy trade bot on Polymarket is a system that detects when a followed wallet places a trade and automatically mirrors that trade in your account in real time. This article covers the full mechanics — how signal detection works, what the risk layer does, how orders are scaled proportionally, and what fill deviation means for how much of the copied signal's value you actually capture.

Signal Detection

The first stage of any copy trade bot is detecting when a followed wallet places a trade. Two fundamentally different methods exist:

WebSocket Connection (Recommended)

A WebSocket maintains a persistent, open connection to Polymarket's on-chain event stream. When a followed wallet broadcasts a transaction, the WebSocket delivers the event within ~100ms of blockchain confirmation. There's no polling interval — the bot receives the signal as soon as the event is broadcast. This is the only approach capable of achieving sub-500ms end-to-end execution.

HTTP Polling (Inferior)

HTTP polling queries Polymarket's API at fixed intervals — every 5, 10, or 30 seconds — checking whether any followed wallets have made new trades since the last check. The median delay is half the polling interval: a 10-second polling bot introduces an average 5-second delay on every signal. On fast-moving markets, this delay translates directly to worse fill prices.

The Risk Layer

Every incoming signal from a followed wallet passes through the risk layer before any order is constructed. The risk layer applies your configured rules in sequence:

1. Per-wallet cap check — is the mirror trade within the allowed USDC amount for this wallet? If not, discard.
2. Category exclusion check — is this market in an excluded category? If so, discard.
3. Liquidity minimum check — does this market's order book have sufficient depth to fill your order without excessive slippage? If not, discard.
4. Portfolio exposure check — is the total open mirror position count at the configured maximum? If so, queue the signal until a position closes.

Signals that fail any check are discarded and logged. You can review filtered signals in the dashboard to understand what's being blocked and adjust your configuration accordingly. The risk layer runs in under 10ms — it adds negligible latency to the execution pipeline.

Order Construction and Scaling

When a signal passes the risk layer, the bot constructs a proportionally scaled mirror order. The scaling logic:

1. Determine the original wallet's position: USDC amount and fill price
2. Calculate share count the original wallet purchased: USDC ÷ fill price
3. Determine your mirror size: min(per-wallet-cap, original_usdc × scale_factor)
4. Construct your order for the proportional share count at market price

Example: Followed wallet places $800 at 55¢ YES (buying ~1,454 shares). Your per-wallet cap is $160 (20% of their size). Your bot constructs an order for ~291 shares at market. If the market has moved to 56¢ by the time your order reaches the chain, you buy 291 shares at 56¢ — a 1.8% fill deviation from the original wallet's entry.

Execution and On-Chain Broadcast

After order construction, the execution pipeline:

1. Order signing — the order is signed using your delegated operator key (trade-only, zero withdrawal capability)
2. Submission to CLOB — signed order submitted to Polymarket's Central Limit Order Book
3. On-chain broadcast — CLOB routes the order to Polygon; transaction broadcast to the network
4. Confirmation receipt — on-chain confirmation received; trade logged with fill price, fill deviation, and latency metrics

The Polygon network's transaction confirmation typically takes 200-300ms under normal load conditions. This is the dominant factor in total end-to-end latency — the signal processing, risk layer, and order construction stages together add roughly 50ms. Total: ~300-400ms on optimized infrastructure.

Fill Deviation Explained

Fill deviation is the percentage difference between your fill price and the original wallet's fill price on the same trade. It's the single most important performance metric for evaluating a copy trade bot:

• Fill deviation = 0%: you entered at exactly the same price as the followed wallet. Theoretically ideal, practically unachievable.
• Fill deviation = 1-2%: your fill is 1-2% worse than the followed wallet's. You captured ~98-99% of the signal's entry price quality. Achievable with sub-500ms execution on normal market conditions.
• Fill deviation = 5-10%: you entered significantly worse. You're capturing 90-95% of the signal's entry price quality — acceptable but degraded.
• Fill deviation = 20%+: the copied wallet's edge is being substantially eroded before you even have a position. Manual copying in fast-moving markets routinely produces this range.

Fast Bot vs. Slow Bot

Metric	Fast Bot (WebSocket, <500ms)	Slow Bot (HTTP polling, 5-30s)
Signal detection	~100ms	~5,000ms average
End-to-end latency	300-500ms	5,000-30,000ms
Fill deviation (normal markets)	1-3%	5-20%+
Fill deviation (fast-moving markets)	2-5%	20-50%+
Off-hours coverage	Full 24/7	Full 24/7
Infrastructure requirement	Optimized VPS or hosted service	Basic VPS

Polycopybot.app's Numbers

Polycopybot.app's documented execution metrics across all trades on the platform:

• Average end-to-end latency: 340ms (WebSocket receipt to on-chain confirmation)
• Average fill deviation: 1.2% across all trades
• Signal detection latency: ~100ms via persistent WebSocket
• Node failover time: sub-80ms (Frankfurt → Singapore automatic)
• Platform uptime (12 months): 99.92%

For the full architectural breakdown, see our Polymarket copy trading bot Polycopybot.app guide.