Copy-trade a wallet

The most-requested integration on Predexon. You pick a profitable wallet, watch every fill it does in real time, and mirror those fills through your own execution at a fraction of the size. You’ll build:

A WebSocket listener that fires on every trade by the target wallet
A handler that translates target-wallet trades into orders for your own execution layer
A scale-and-execute path that mirrors on the same venue

Endpoints used: 1 WebSocket channel + 1 REST endpoint. Runs on Dev plan or higher (WebSocket requires Dev+).

Predexon supplies the detection side: the real-time fill stream and the wallet analytics to vet your target. Execution happens through the venue’s own API (e.g. the Polymarket CLOB client) — shown below as a stub you wire to your client of choice.

Architecture

Step 1 — Verify the target

Before mirroring, check they’re actually profitable. Pull the wallet profile:

import os, requests, time, json
from websockets.sync.client import connect

DATA = "https://api.predexon.com"
WSS = "wss://wss.predexon.com/v1"
KEY = os.environ["PREDEXON_API_KEY"]
H = {"x-api-key": KEY}
TARGET = "0xSmartTraderAddressHere"

profile = requests.get(f"{DATA}/v2/polymarket/wallet/{TARGET}", headers=H).json()
print(f"Profit: ${profile['realized_profit_usd']:,.0f}  ROI: {profile['roi']:.1%}")
assert profile["realized_profit_usd"] > 50_000, "Target isn't profitable enough"

Re-run this check daily — wallets degrade.

The trades channel takes a users filter. You’ll receive every fill they take in real time, on both V1 and V2 Polymarket contracts.

def subscribe():
    return json.dumps({
        "action": "subscribe",
        "platform": "polymarket",
        "version": 1,
        "type": "orders",
        "filters": {"users": [TARGET]},
    })

with connect(f"{WSS}/{KEY}") as ws:
    ws.send(subscribe())
    for raw in ws:
        msg = json.loads(raw)
        if msg.get("type") != "event":
            continue
        handle_trade(msg["data"])

Step 3 — Scale and mirror

The hardest part of copy-trading is sizing. Mirror their trade as a fraction of their original size, capped by your venue balance. Execution goes through your own venue client:

SIZE_RATIO = 0.10              # mirror 10% of their size
MAX_PER_TRADE_USD = 500

def execute_on_venue(token_id, side, size, order_type="market", price=None):
    # your venue-native execution — e.g. Polymarket CLOB client
    # from py_clob_client.client import ClobClient ...
    raise NotImplementedError

def handle_trade(trade):
    # only mirror trades initiated by the target wallet (not against them)
    if trade["user"].lower() != TARGET.lower():
        return
    # only follow buys; let me close on my own logic
    if trade["side"] != "BUY":
        return

    target_shares = float(trade["shares_normalized"])
    target_price = float(trade["price"])
    notional = target_shares * target_price

    # scale
    mirror_shares = target_shares * SIZE_RATIO
    mirror_notional = mirror_shares * target_price
    if mirror_notional > MAX_PER_TRADE_USD:
        mirror_shares = MAX_PER_TRADE_USD / target_price

    # the target trades on Polymarket — mirror directly on the same token_id
    resp = execute_on_venue(
        token_id=trade["token_id"],
        side="buy",
        size=round(mirror_shares, 2),
        order_type="market",       # or "limit" at target_price * 1.005
    )
    print(f"Mirrored: {trade['token_id']}  shares={mirror_shares:.2f}  → {resp}")

The example above mirrors on the same venue (Polymarket → Polymarket), which is the most reliable copy-trading path — the token_id in the event is exactly the token your venue client trades.

Step 4 — Run it under supervision

Things that will go wrong in production:

Failure	Mitigation
WebSocket disconnect	Wrap the loop with reconnect + resume. See Subscriptions.
Mirror order fails (insufficient balance)	Catch the venue error, alert yourself, top up the venue, don’t auto-retry.
Target sells before you fill	Use market orders + smaller size; or accept the slippage as part of the cost.
Target wallet changes strategy	Re-pull the wallet profile daily; pause mirroring if `realized_profit` drops.
You mirror a trade and they immediately reverse	Build a “follow exits too” version: also handle `side: "SELL"` to close mirrored positions.

For the simplest possible production version, also subscribe to the activity channel to mirror splits, merges, and redemptions.

Variations

Multi-wallet copy-trading: subscribe with filters: {"users": [w1, w2, w3, ...]} and route each trade to the right end-user account in your DB.
Filtered copy-trading: only mirror trades above a notional threshold, or in specific market categories.
Agent-driven copy-trading: replace the WebSocket loop with the Agent Cookbook recipe 4, which polls and reasons about whether to mirror.

Reference

WebSocket trades channel — filter shape, event payload
Wallet P&L — track how your mirrored book performs vs. the target
Wallet Profile — for the daily target check
Best Practices — WebSocket reconnect pattern

Welcome

Guides for your use case

Cookbook

Core concepts

Account & access

Integrations

Architecture

Step 1 — Verify the target

Step 3 — Scale and mirror

Step 4 — Run it under supervision

Variations

Reference

​Architecture

​Step 1 — Verify the target

​Step 2 — Subscribe to their trades

​Step 3 — Scale and mirror

​Step 4 — Run it under supervision

​Variations

​Reference

Architecture

Step 1 — Verify the target

Step 2 — Subscribe to their trades

Step 3 — Scale and mirror

Step 4 — Run it under supervision

Variations

Reference