Portfolio monitor

If you’re building any kind of portfolio UI or risk dashboard, this is the loop you need. Point it at any wallet address — your own, a fund’s, a trader you track — pull its positions and P&L from the Data API, then layer live updates via WebSocket. You’ll build:

Initial state load (positions + P&L) from REST
Live deltas (fills, splits, redemptions) from WebSocket
A reconciliation step that runs periodically

Endpoints used: 2 REST + 2 WebSocket channels. Dev plan and up (WebSocket requires Dev+).

Architecture

Step 1 — Boot the state

Everything is keyed on the wallet address — no account setup needed, and it works for any address on Polymarket, not just your own.

import os, requests, json, time
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}
WALLET = "0xWalletToMonitor"

def boot_state():
    # 1. Open positions with cost basis, current value, and P&L
    positions = requests.get(
        f"{DATA}/v2/polymarket/wallet/positions/{WALLET}",
        headers=H,
        params={"limit": 200},   # open positions only by default
    ).json()["positions"]

    # 2. P&L — summary (realized, unrealized, fees) + realized time series
    pnl = requests.get(
        f"{DATA}/v2/polymarket/wallet/pnl/{WALLET}",
        headers=H,
    ).json()

    return {
        "wallet": WALLET,
        "positions": positions,
        "pnl": pnl,
        "loaded_at": time.time(),
    }

state = boot_state()
print(f"Loaded {len(state['positions'])} open positions, "
      f"total P&L ${state['pnl']['total_pnl']:,.2f}")

Pass include_closed=true on the positions call if your dashboard also shows resolved/closed positions. Default is open (non-zero-balance) positions only.

Two channels matter for portfolio updates: trades (fills) and activity (splits / merges / redemptions). Filter both to the wallet.

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

A single Polymarket match emits both per-maker and taker-aggregate order_filled rows. Apply only events where data["user"] equals your wallet to avoid double-counting — see Maker vs Taker emissions.

Step 3 — Apply each delta to state

A fill changes a position’s size and cost basis. An activity event (split/merge/redeem) restructures positions. Worth modeling both — but at minimum, the trades handler is the must-have.

def apply_trade(state, t):
    """Update a position from a fill event."""
    if t["user"].lower() != state["wallet"].lower():
        return   # counterparty emission — not this wallet's fill
    token_id = t["token_id"]
    size = float(t["shares_normalized"]) * (1 if t["side"] == "BUY" else -1)
    price = float(t["price"])

    pos = next((p for p in state["positions"] if p.get("token_id") == token_id), None)
    if pos is None:
        # new position
        state["positions"].append({
            "token_id": token_id,
            "condition_id": t["condition_id"],
            "size": size,
            "avg_price": price,
        })
    else:
        # weighted-average cost basis
        new_size = pos["size"] + size
        if new_size == 0:
            state["positions"].remove(pos)
        else:
            pos["avg_price"] = (
                (pos["avg_price"] * pos["size"] + price * size) / new_size
            )
            pos["size"] = new_size

def apply_activity(state, a):
    """Activity events restructure positions (splits, merges, redemptions)."""
    if a["event_type"] == "redemption":
        # winning side pays $1/share, losing side pays $0; remove resolved positions
        state["positions"] = [
            p for p in state["positions"] if p["condition_id"] != a["condition_id"]
        ]
    # Splits / merges / NegRisk conversions: re-pull positions in step 4

Step 4 — The main loop

def run():
    state = boot_state()

    last_reconcile = time.time()

    with connect(f"{WSS}/{KEY}") as ws:
        for msg in subscribe_msgs(WALLET):
            ws.send(msg)

        while True:
            try:
                ws.settimeout(60)
                raw = ws.recv()
                msg = json.loads(raw)
                if msg.get("type") != "event":
                    continue
                if msg["subscription_id"].endswith("trades"):
                    apply_trade(state, msg["data"])
                elif msg["subscription_id"].endswith("activity"):
                    apply_activity(state, msg["data"])
                publish(state)   # send to UI / dashboard
            except TimeoutError:
                pass

            # Reconcile every 60s — defends against missed events
            if time.time() - last_reconcile > 60:
                state = boot_state()
                last_reconcile = time.time()
                publish(state)

def publish(state):
    # your UI delivery — websocket to frontend, Redis pub/sub, etc.
    print(f"[{time.strftime('%H:%M:%S')}] {len(state['positions'])} positions, "
          f"total P&L ${state['pnl']['total_pnl']:.2f}")

What the UI does with this state

Display	Source
Open positions table	`state["positions"]`
Mark-to-market	`position.size * latest_price` — fetch latest_price from Market Price
Unrealized P&L	`state["pnl"]["unrealized_pnl"]`, or `(latest_price - avg_price) * size` per position
Realized P&L over time	`state["pnl"]["pnl_over_time"]` — cumulative realized P&L series
Fees	`state["pnl"]["fees_paid"]` / `state["pnl"]["fees_refunded"]`
Recent fills	Append the trades event stream to a feed

For periodic mark-to-market, the cheapest pattern is batch the latest prices for all unique token_ids in the positions list and refresh every few seconds.

Variations

Multi-wallet dashboard: subscribe with filters: {"users": [w1, w2, ...]} on both channels and keep one state object per wallet; boot each from the same two REST calls.
Alerting: add thresholds — alert on unrealized loss > X, on a new position above $Y, on a redemption event.
Per-market P&L drill-down: pass condition_id to Wallet P&L to break out a single market (correctly handles splits/merges).
Historical equity curve: pair with Wallet Volume Chart for cumulative-volume overlays.

Reference

Wallet Positions — open positions with cost basis, include_closed for history
Wallet P&L — summary + realized P&L time series
WebSocket trades, activity
Best Practices — WebSocket reconnect

Welcome

Guides for your use case

Cookbook

Core concepts

Account & access

Integrations

Architecture

Step 1 — Boot the state

Step 3 — Apply each delta to state

Step 4 — The main loop

What the UI does with this state

Variations

Reference

​Architecture

​Step 1 — Boot the state

​Step 2 — Subscribe to live deltas

​Step 3 — Apply each delta to state

​Step 4 — The main loop

​What the UI does with this state

​Variations

​Reference

Architecture

Step 1 — Boot the state

Step 2 — Subscribe to live deltas

Step 3 — Apply each delta to state

Step 4 — The main loop

What the UI does with this state

Variations

Reference