Guide July 28, 2026 · updated July 31, 2026

Inspect wallet behavior: reading the story in Polymarket trade history

A wallet's trade history tells a story — entries, exits, discipline. Here's how to collect Polymarket trades per wallet and read behavior, not just P/L.

Every Polymarket wallet writes a story, one trade at a time — and if you collect those trades, you can read it: when they entered, when they added, when they took profit, and whether they do it the same way twice. That story, not a headline P/L number, is how you decide which wallets are worth following and what strategy they’re actually running.

Here’s the difference in one pair of pictures.

The profile tells you the outcome

Polymarket’s public profile for a wallet shows you the aggregates:

Polymarket wallet profile: $25.4K all-time profit, $18.3K positions value, 16,710 predictions

This wallet has made $25.4K all-time across 16,710 predictions, with $18.3K currently deployed. Genuinely useful — it tells you this account is active, sizeable, and net-profitable. What it can’t tell you is how. Is this a sharp directional trader? A market maker collecting spread across thousands of tiny fills? Did the equity curve climb steadily, or is it one lucky $4K win propping up noise? The flat parts and the jump in that P/L chart hint at regime changes — but aggregates can’t explain themselves.

If you’re choosing wallets to copy-trade, that distinction is everything. You don’t want to copy an outcome. You want to copy a process — which means you need to see it.

The history tells you the story

Now the same wallet, read at the trade level. We took one market — “Will WTI dip to $80 in July 2026?” — pulled every trade in it from the feed, and plotted one wallet’s activity against the price line:

Custom tool showing 169 trades from 56 wallets on one Polymarket market, with one wallet's buys and sells plotted against the price line

One four-hour window: 169 trades from 56 wallets, with our wallet (0x8888…0b39) highlighted. And suddenly there’s a narrative you can evaluate:

  • Entry at 0.58 before the move, adding through 0.61–0.63 as the odds climbed;
  • Profit-taking at 0.73–0.74 — near the local top, not after the retrace;
  • After the drop, a small re-entry at 0.60 — the same thesis, re-established cheaper.

That’s a disciplined swing pattern: early entry, scale-in, sell into strength, reload on pullback. Whether you’d follow this wallet is now an informed judgment — and repeated across markets and weeks, the pattern (or its absence) becomes the answer. The same view instantly exposes other behaviors too: wallets buying every dip and never selling (conviction holders), wallets on both sides at tiny size all day (market makers — the maker/taker roles in the feed make this explicit), or wallets that always arrive after the move (momentum chasers you don’t want to be behind).

The view in that screenshot is a live product: Trades Inspector, available to every Polyflux subscriber. Paste any Polymarket market URL, chart the price, click-select a time window, and see every wallet that traded it — ranked by volume or P&L, with per-wallet breakdowns (bought, sold, average prices, realized and unrealized P&L, fees) and the full, exportable trade tape, every fill linked to its transaction. If you want to read a wallet’s story right now, without building anything, that’s the fastest way — it’s included in the 24-hour free trial.

If you’d rather build your own view — or need this data feeding a bot rather than a screen — the interface is not the hard part anymore. The data is. Which brings us to how you get it.

Building the dataset

Everything above is derived from the same trade events the stream already delivers — each one carrying wallet_address, asset_id, size, price, operation_type, and a millisecond timestamp. Collecting them is a loop and an append:

# pip install polyflux-client
import asyncio, json
from polyflux import Client

async def main():
    client = Client("YOUR_API_KEY")
    with open("trades.jsonl", "a") as out:
        async for trade in client.trades():
            out.write(json.dumps(trade.raw) + "\n")

asyncio.run(main())

Leave it running and the dataset builds itself: every wallet, every market, timestamped to the millisecond. From there, analysis is a groupby(wallet_address) away — and the MarketCatalog turns each asset_id into a market name so your stories have titles. (If you’re also maintaining live positions from the same events, the snapshot + deltas pattern applies unchanged.)

Need history you weren’t around to record? Recording forward only gets you data from today. If your analysis needs the full trade record over a longer period — backtesting a wallet-selection rule, or reconstructing months of a specific wallet’s behavior — write to [email protected] and tell us the scope; we can arrange access to the complete Polymarket trade archive.

Reading like an analyst: what to look for

Once you can replay any wallet’s story, a few patterns separate signal from luck:

  • Timing vs. the move — consistently early entries are an edge; consistently late ones are a warning, however profitable the profile looks.
  • Exit discipline — does profit-taking happen into strength (like the 0.73–0.74 sells above), or only after giving gains back?
  • Repeatability — the same shape across many markets is a strategy; one great market is an anecdote.
  • Sizing — does size grow with conviction and shrink after losses, or is it erratic?

A wallet that passes those checks is a candidate worth following in real time. One that doesn’t — no matter its leaderboard rank — just taught you something cheaper than copying it would have.

Two ways to start reading wallets today: open Trades Inspector and inspect your first market in minutes — no code, included in the free trial — or grab a key and run the loop above so your own dataset is already growing. And for the archive going back further, [email protected].

Frequently asked questions

How do I analyze a Polymarket wallet's trading history?
Collect the wallet's trades — each one carries asset_id, size, price, side, and a timestamp — and replay them against the market's price. Entries, exits, sizing, and timing show the wallet's actual strategy, which aggregate profit numbers can't.
Is there a tool to see who's trading a Polymarket market?
Yes — Trades Inspector (polyflux.io/trades-inspector) does this without code: paste any Polymarket market URL, pick a time window on the price chart, and see every wallet that traded it, ranked by volume or P&L, with every fill in an exportable trade tape. It's included with a Polyflux subscription and the 24-hour free trial.
How do I find good Polymarket wallets to copy trade?
Watch the live feed for large or consistently active wallets, then read their history before following: did they enter early and take profit with discipline across many markets, or win once on size? Behavior over a period is the filter; a single P/L number isn't.
Can I get historical Polymarket trade data?
Two ways: run the Polyflux stream and store every trade from now on — the dataset builds itself — or, if you need all Polymarket trades over a longer past period, contact [email protected] for access to the full historical archive.
What can a wallet's trade history tell you that its profile can't?
A profile shows aggregates: total P/L, positions value, prediction count. The trade history shows process — when the wallet entered relative to the odds, whether it added or cut, where it took profit, and whether the pattern repeats across markets.
How is this different from just watching the whale leaderboard?
A leaderboard ranks outcomes. Reading history evaluates process: two wallets with identical profit can be a disciplined repeatable strategy and a single lucky hit. Only the trade-by-trade story distinguishes them — and only process is worth copying.
← All articles