Insider scanner - 0xinsider API

By the end you have a review queue of flagged Polymarket trades. Each row carries the wallet’s grade and how many markets it has traded, the direction large money is flowing on that market, and the graded wallets holding the same side. A flag is a lead, not proof. 0xinsider raises one when a trade’s suspicion score reaches 60, scored from the wallet’s age and the size and shape of the fill. Nothing in that score reads the news or knows how the market resolved. You need a Pro API key. See Authentication.

1. Pull suspicious live trades

Whale trades carries a stored suspicion score on every trade. Set suspicious_only=true to keep only the rows scoring 60 or more, which is the threshold that makes a trade a flag. suspicion_track names which of the three scorers produced the score.

Value of `suspicion_track`	What the scorer matched
`whale`	A large trade that scores on at least two more signals: a new wallet, a bet against the crowd at a long price, or other new wallets on the same market.
`fresh_conviction`	A brand-new wallet betting against the crowd at a long price, at a size too small to count as a whale trade.
`sliced_position`	One wallet splitting a large position into many small fills on one market in a short window.

import os

import requests

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

trades = requests.get(
    f"{BASE}/whale-trades",
    params={"suspicious_only": "true", "limit": 50},
    headers=H,
    timeout=30,
).json()

for tr in trades["data"]:
    who = tr["trader"]["username"] or tr["trader"]["address"][:10]
    print(
        tr["suspicion_score"], tr["suspicion_track"], who, tr["side"],
        tr["outcome"], tr["size_usd"], tr["market"]["title"],
    )

2. Pull the flagged trades

Suspicious trades returns the same flagged trades, highest suspicion score first, and adds the scorer’s own scores and evidence. To read one flag on its own, Suspicious trade takes its rf_ id.

Parameter	Description
`min_suspicion`	The lowest score to return, from 0 to 100. The flag threshold of 60 still applies underneath it, so a lower value returns nothing extra.
`severity`	`flag` returns the stored flags. `watch` returns no rows, because 0xinsider stores no watch-level flags.
`mode`	`live`, the default, serves pages from a cache up to 120 seconds old. `stable` holds one set of scores across every page you request, and answers `400` with `error.reason` `cursor_expired` when those scores or your filters change.

Field	Meaning
`scores.size`, `scores.fresh_wallet`	The size and new-wallet components of the score, when the scorer recorded them. They are `null` otherwise.
`scores.timing`, `scores.edge`	Always `null`. The live scorer does not record either one.
`evidence`	The raw signals the scorer stored for this trade, as JSON.
`created_at`	When the trade happened, not when 0xinsider flagged it.

flags = requests.get(
    f"{BASE}/suspicious-trades",
    params={"severity": "flag", "min_suspicion": 70, "limit": 50},
    headers=H,
    timeout=30,
).json()

for f in flags["data"]:
    s = f["scores"]
    who = f["trader"]["username"] or f["trader"]["address"][:10]
    print(f["id"], f["suspicion_score"], who, f["market"]["title"], "size", s["size"], "fresh", s["fresh_wallet"])

3. Add the wallet and the market

A flag names the wallet but does not grade it, so read the wallet and its market before you act on the lead.

Endpoint	What to read from it
Trader	`grade`, `stats.markets_traded`, and `sync_status`. A wallet 0xinsider does not track answers `200` with `sync_status` `unknown`, not a `404`.
Market intel	`sharp_money.direction`, which is `YES` or `NO`, and `sharp_money.net_flow_usd` over the `timeframe` you asked for. `smart_money` is a deprecated copy of the same object, so read `sharp_money`.

Then compare the flagged trade’s side and outcome with sharp_money.direction. A flagged wallet buying the side the net flow is already on is a different story from one taking the other side of it.

flag = flags["data"][0]
addr = flag["trader"]["address"]
cond = flag["market"]["condition_id"]

trader = requests.get(f"{BASE}/trader/{addr}", headers=H, timeout=30).json()["data"]
intel = requests.get(
    f"{BASE}/market/{cond}/intel", params={"timeframe": "24h"}, headers=H, timeout=30
).json()["data"]

print("grade:", trader["grade"], "markets:", trader["stats"]["markets_traded"], trader["sync_status"])
print(
    "sharp money:", intel["sharp_money"]["direction"],
    intel["sharp_money"]["net_flow_usd"], "over", intel["timeframe"],
)

4. Check who else holds that side

Market holders lists every S, A, and B wallet holding open shares in the market, from a complete scan of Polymarket’s holders. Use outcome=yes or outcome=no to keep one side; min_grade defaults to B, so raise it to A or S to narrow the list.

curl -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/market/0x123.../holders?outcome=yes&min_grade=A"

Every row carries side, grade, shares, and current_value_usd. A wallet holding both outcomes is listed once, on whichever side it nets to. is_new_wallet appears only on a wallet that earns at least one badge, and it is true when the wallet’s first trade was under 30 days ago.

5. Get push alerts

Subscribe a webhook to suspicious_trade_flagged to hear about a flag as it is raised instead of polling. It fires the first time a trade’s suspicion score crosses the flag threshold, and it is Pro only. insider_radar_flag_raised is the older spelling of the same event, and an endpoint subscribed to it keeps receiving that spelling. The delivery’s data object carries trade_id, wallet, trader_id, condition_id, suspicion_score, track, side, size, and price. Two of those read differently from the fields with the same names on a whale trade: side is the outcome traded, yes or no, and size is a share count rather than a USD amount. track takes the same three values as suspicion_track in step 1. See Webhooks for creating the destination and checking the signature.

What this does not do

Prove anything. The score is a heuristic over wallet age, trade size, conviction, clustering, and fill pattern. It reads no news and knows nothing about the outcome.
Place an order. No endpoint on this API does, so what you do with a lead is yours to code.
Grade the wallet on the flag. A flagged trade’s trader carries id, address, and username only. Read the grade from Trader, as step 3 does.
Return a watch severity. Every stored flag is flag, so filtering for watch returns an empty list.
Report how old the wallet is on chain. is_new_wallet counts from the wallet’s first trade as 0xinsider recorded it, which can be later than the wallet’s first transaction.

Alert bot posts each new trade to a channel. Scores explains review_score (formerly signal_score), which is a separate number from the suspicion score on this page.

​1. Pull suspicious live trades

​2. Pull the flagged trades

​3. Add the wallet and the market

​4. Check who else holds that side

​5. Get push alerts

​What this does not do

​Related