Copy-trade signals - 0xinsider API

By the end you have three things:

A follow list of S and A wallets, ranked by how easy each one is to copy.
A poll that prints every new large trade from a wallet on that list, with the Polymarket token id your own order client needs.
The fill-by-fill history behind any one of those positions.

You need a Pro API key. See Authentication. The API reads Polymarket and places no orders, so the decision and the order stay in your own code.

1. Build the follow list

Leaderboard returns ranked wallets, highest score first. It lists S, A, and B wallets only, and it has no min_grade parameter, so drop the B wallets in your own code.

Parameter	Description
`limit`	Wallets per page, from 1 to 100. The default is 20.
`strategy`	Keeps one trading style, such as `swing_trader`. See Strategy types.

Field	Meaning
`grade`	`S`, `A`, or `B`. A grade is the wallet’s settled profit and loss, ranked against every other tracked wallet. See Grades.
`realized_pnl`	Profit and loss on positions the wallet has already closed. Fees are included and rebates are added.
`pnl`	Profit and loss including open positions, so it moves with the price. Prefer `realized_pnl` when you compare wallets.

To page, send the response’s next_cursor back as cursor. If the ranking is rebuilt while you page, or you change category or strategy, the API answers 400 with error.reason cursor_expired. Throw away the rows you collected and request the first page again: continuing from the old cursor would skip wallets.

import os
from datetime import datetime, timedelta, timezone

import requests

BASE = "https://api.0xinsider.com/api/v1"
H = {"Authorization": f"Bearer {os.environ['OXINSIDER_API_KEY']}"}

leaders = requests.get(
    f"{BASE}/leaderboard", params={"limit": 100}, headers=H, timeout=30
).json()
follow = [t["address"] for t in leaders["data"] if t["grade"] in ("S", "A")]

2. Score each wallet on how easy it is to copy

Batch traders reads 1 to 25 wallets in one request. Send expand: ["quant_metrics"] to get copy_score on each one.

Field	Meaning
`copy_score`	How easy this wallet is to follow, from 0 to 100. It starts at `smart_score` and subtracts penalties: fewer than 50 markets traded, concentrated positions, position sizing above roughly 2x Kelly, a worst single-trade loss over 30%, and inconsistent edge.
`smart_score`	The same skill score with none of those penalties subtracted, from 0 to 100.
`quant_metrics`	Absent unless you expand it, and absent when the stored metrics are 6 hours old or older. Read it with `.get`.
`status`	`ok` or `error`, on each item separately. One wallet that fails does not fail the request.
`data_quality`	How old each part of the trader is. The `ranking` group dates the grade and the scores: its `status`, and its `as_of` when the read can date it.

Check data_quality before you act on a grade. fresh means the group is tracked and has a clock, not that the clock is recent enough for you: compare as_of with your own limit. unknown means this read cannot date the group. Treat it as not current, never as recent. The official SDKs apply this rule in one call: assessDataQuality in TypeScript, assess_data_quality in Python, AssessDataQuality in Go. A copy_score of null means the wallet has too little history to score. It never means the wallet scored badly, so do not read it as a low score. The code below sorts those wallets to the bottom.

batch = requests.post(
    f"{BASE}/traders/batch",
    json={"traders": follow[:25], "expand": ["quant_metrics"]},
    headers=H,
    timeout=30,
).json()

ranked = []
for item in batch["data"]:
    if item["status"] != "ok":
        print("skip:", item["input"], item["error"]["message"])
        continue
    t = item["data"]
    ranking = next(
        (g for g in t["data_quality"]["field_groups"] if g["group"] == "ranking"), None
    )
    if ranking is None or ranking["status"] != "fresh" or "as_of" not in ranking:
        # unknown, partial or unavailable: this read cannot date the grade.
        print("skip, grade not dated:", t["address"], ranking and ranking.get("reason"))
        continue
    as_of = datetime.fromisoformat(ranking["as_of"].replace("Z", "+00:00"))
    if datetime.now(timezone.utc) - as_of > timedelta(hours=6):
        print("skip, grade older than 6 hours:", t["address"], ranking["as_of"])
        continue
    qm = t.get("quant_metrics") or {}
    ranked.append((qm.get("copy_score"), t["address"], t["username"], t["grade"]))

ranked.sort(key=lambda r: r[0] or 0, reverse=True)
for score, address, username, grade in ranked:
    print(score, grade, username or address[:10])

3. Watch for new trades

Whale trades lists recent large trades, newest first. It has no wallet parameter, so compare each row’s trader.address against your follow list in code. To read one wallet’s past trades instead, Whale trades history takes a trader parameter.

Parameter	Description
`min_grade`	Keeps wallets at this grade or better. `A` keeps S and A.
`min_size`	Smallest trade to return, in USD. The default is $5,000.
`limit`	Trades per page, from 1 to 100. The default is 20.

Field	Meaning
`id`	The trade’s own id. Deduplicate on it, because a poll re-reads the newest rows every time.
`side`	`BUY` or `SELL`: the direction the wallet traded.
`outcome`	Which outcome the wallet traded, such as `Yes`, `No`, or a team name. It is `null` on a market with more than two outcomes.
`token_id`	The Polymarket CLOB token id for that outcome, which your order client needs to place an order. It is `null` when 0xinsider has no token id stored for the market, and on any Polymarket trade recorded before April 2, 2026.

follow_set = {a.lower() for a in follow}
seen = set()


def new_moves(min_size=10000):
    page = requests.get(
        f"{BASE}/whale-trades",
        params={"min_grade": "A", "min_size": min_size, "limit": 100},
        headers=H,
        timeout=30,
    ).json()
    moves = []
    for tr in page["data"]:
        if tr["id"] in seen:
            continue
        seen.add(tr["id"])
        if tr["trader"]["address"].lower() in follow_set:
            moves.append(tr)
    return moves


for tr in new_moves():
    who = tr["trader"]["username"] or tr["trader"]["address"][:10]
    print(
        who, tr["side"], tr["outcome"], f'${tr["size_usd"]:,.0f}',
        "@", tr["price"], tr["market"]["title"], tr["token_id"],
    )

To hear about a trade within seconds of 0xinsider storing it, subscribe a webhook to whale_trades_inserted and run the same address match. Alert bot builds that.

4. Read the entry and exit history

Position timeline returns every stored fill for one wallet in one market, newest first. The condition_id parameter is required: take it from market.condition_id on the trade you matched in step 3.

curl -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/trader/0x204f72f35326db932158cba6adff0b9a1da95e14/position-timeline?condition_id=0x123..."

Each event carries running_amount, the wallet’s share balance after that fill, and running_avg_price, the buy-weighted average price it paid. A sell does not change the average. Both include fills from earlier pages, so you do not have to add them up yourself. 0xinsider stores a timeline only for the wallets it syncs most closely. For any other wallet the route answers 404 with error.reason trader_not_tracked. Do not retry that wallet: the answer will not change.

What this does not do

Signal before the fill. Every trade in the feed already executed on Polymarket. traded_at is when the fill happened, and price is what that wallet paid, not a quote for you.
Place, cancel, or read an order. No endpoint on this API does. Route your order through your own Polymarket client.
Filter the live feed by wallet. Match addresses in your own code, as step 3 does.
Show a small fill from a wallet you follow. The feed carries large trades only, so anything too small to be recorded as a whale trade never appears in it.
Serve a timeline for a wallet 0xinsider does not sync closely.

Backtest a trader checks a wallet’s profit and loss curve before you follow it. Quant metrics defines copy_score and smart_score.

​1. Build the follow list

​2. Score each wallet on how easy it is to copy

​3. Watch for new trades

​4. Read the entry and exit history

​What this does not do

​Related

1. Build the follow list

2. Score each wallet on how easy it is to copy

3. Watch for new trades

4. Read the entry and exit history

What this does not do

Related