Polymarket Analytics: An On-Chain Data Analysis Guide for Quants

The fastest path to actionable Polymarket signals is pulling trade and settlement events directly from the on-chain record, normalizing them into wallet-level ledgers, and layering in real-time delivery for anything you plan to trade on. Surface-level price charts hide the parts that matter: wallet concentration, timing relative to news, and resolution accuracy by cohort. On-chain data exposes all three.

To build this pipeline, you need:

• Primary events to extract: order fills/trade events, conditional token mints and redemptions, and USDC settlement transfers on Polygon.

• Minimal normalization: dedupe by transaction hash and log index, tag maker versus taker legs, and map token IDs to outcomes before anything touches a P&L calculation.

• Delivery mechanism: REST or SQL for backtesting, WebSocket or streaming for anything running live.

For unified coverage across markets and venues, the Assymetrix Data API indexes this at scale. If you’re building it yourself, Polymarket’s own API, Dune, Goldsky, and Allium cover the open-source route.

Key Takeaways

Reliable Polymarket analytics depends on mapping raw settlement events to normalized wallet ledgers, then layering wallet-scoring and cross-venue checks on top of clean data.

Table of Contents

• How Polymarket Records Trades and Settlements On-Chain

• Which Metrics Actually Matter for Quant Trading?

• Where to Get Polymarket On-Chain Data

• Common Data Pitfalls and How to Clean Polymarket Feeds

• Starter SQL Queries for Trade-Level Extraction

• Analytical Frameworks: Wallets, Smart Money, and Cross-Venue Checks

• Building a Polymarket Market Screener with the Assymetrix SDK

• Sources

• FAQ

How Polymarket Records Trades and Settlements On-Chain

Polymarket runs a hybrid lifecycle: orders are created and matched off-chain, but settlement lands on-chain through the Exchange contract on Polygon, using conditional tokens (ERC1155) and USDC. That split matters because event timing on-chain lags the moment a trade actually happens off-chain, per Polymarket’s own order lifecycle documentation.

The artifacts worth indexing:

• Order fill / trade events — emitted by the Exchange contract when matched orders settle.

• Conditional token transfers — mints, burns, and redemptions tied to outcome resolution.

• USDC transfers — the collateral leg of every position.

• Settle/redeem events — fired when a market resolves and payouts execute.

For each, capture: transaction hash, block timestamp, from/to addresses, tokenId/outcome ID, amount, price, and any fee fields. Miss the timestamp granularity and your event-time analysis falls apart before it starts.

Which Metrics Actually Matter for Quant Trading?

Volume alone tells you almost nothing about edge. What separates a usable dataset from a vanity dashboard is the metric stack behind it:

• Volume, split maker/taker — total notional traded, with maker and taker legs separated to reveal who’s providing liquidity versus consuming it.

• Open interest — outstanding conditional token supply per market, a proxy for how much capital is still at risk.

• Liquidity depth — resting order size within a defined price band, usually the top 1-2% around mid.

• Wallet-level realized/unrealized P&L — mark closed positions at settlement price, open positions at current mid.

• Concentration measures — share of total P&L held by the top decile of wallets.

Portfolio sizing decisions lean on liquidity depth and open interest; signal filters lean on wallet P&L and concentration; monitoring dashboards need all five refreshed continuously. Strategy guides analyzing Polymarket wallets consistently find P&L concentrated among a small cohort of top-performing wallets, which is exactly why wallet-level tracking outperforms aggregate volume as a signal source.

Pro Tip: Recompute your P&L metrics after every fee schedule change. Polymarket’s March 2026 fee rollout turned several previously profitable taker strategies into break-even ones overnight.

Where to Get Polymarket On-Chain Data

Every data source trades off coverage, latency, and normalization effort differently. Here’s how the main options stack up:

• Polymarket API/WebSockets — official, real-time, but raw and unnormalized; you build the schema yourself.

• Dune dashboards/SQL — excellent for exploratory queries and public dashboards, but query latency and rate limits make it a poor fit for production alerts.

• Goldsky/Allium streaming feeds — indexed, low-latency blockchain data, though you still need to build Polymarket-specific schema logic on top.

• Enterprise APIs (Assymetrix) — normalized schema, wallet history, and cross-venue coverage delivered through one integration, built for production signal pipelines.

A practical step-by-step guide to on-chain analytics on Polymarket recommends combining Etherscan-style explorers, Dune, and streaming vendors for early-stage signal engineering. That’s the right call for hypothesis testing. Community consensus is consistent here: Dune wins for exploratory SQL, but production systems that trade on the signal need normalized, low-latency infrastructure that a raw explorer or dashboard tool can’t provide. Use Dune to prove a hypothesis fast; move to an enterprise feed once you’re ready to run it live.

Common Data Pitfalls and How to Clean Polymarket Feeds

Raw on-chain data lies to you in predictable ways. The five that trip up most new pipelines:

• Double-counting both sides of a trade — each fill often emits two legs; sum them and you double your volume.

• Wash trades — self-crossing wallets inflate volume without changing risk.

• Resolution spikes — settlement events create a burst of transfers that look like organic trading activity but aren’t.

• USDC token variants — bridged or wrapped USDC contracts can slip through naive filters.

• Inconsistent outcome identifiers — token IDs shift across market versions if you’re not careful mapping them.

Fix these with dedupe logic on transaction hash plus log index, a filter for internal transfers between known contract addresses, explicit USDC contract allowlisting, and separate handling for settlement events versus regular trades.

Pro Tip: Wash trades usually show up as round-trip fills between two wallets within the same block or the next one. Flag any pair of wallets trading against each other more than a handful of times in a session and you’ll catch most of it before it corrupts your volume numbers.

Starter SQL Queries for Trade-Level Extraction

A basic Dune-style extract for trade-level rows looks like this:

SELECT tx_hash, block_time, wallet, market_id, outcome, price, qty, fee
FROM polymarket_fills
WHERE block_time > now() - interval '30' day
ORDER BY block_time DESC

SELECT tx_hash, block_time, wallet, market_id, outcome, price, qty, fee
FROM polymarket_fills
WHERE block_time > now() - interval '30' day
ORDER BY block_time DESC

From there, build a rolling maker/taker volume window and a simple conviction score:

1. Partition fills by wallet and 24-hour window.

2. Sum taker-side notional separately from maker-side notional.

3. Score conviction as the ratio of position size added to a market versus that wallet’s trailing 30-day average position size.

For historical windows spanning months, partition by block_time and index on market_id plus wallet together.

Analytical Frameworks: Wallets, Smart Money, and Cross-Venue Checks

Wallet performance analysis starts with trade sequencing: order fills by timestamp, attribute realized P&L to closed positions, and score skill using win rate alongside an information ratio across a fixed lookback window (30, 90, and 180 days give you enough contrast to separate luck from skill).

Smart Money tracking works by flagging wallets with consistently high realized P&L and low variance, then clustering related addresses through shared funding sources or correlated entry timing. Lead-lag tests, checking whether a wallet’s position build-up precedes market-wide price moves by minutes or hours, separate genuine informed trading from lucky guesses.

Microstructure and cross-venue checks apply event-time ordering around news catalysts. Research into Polymarket’s order book microstructure shows observable latency windows and repricing patterns that quants can test directly against block timestamps and log-index order. Run the same event-time test against Kalshi to validate genuine cross-venue arbitrage signals rather than noise from asynchronous data feeds.

Pro Tip: Treat single Polymarket positions as portfolio components, not standalone bets. Correlated markets and NegRisk multi-outcome structures let you build market-neutral positions that beat isolated directional trades in risk-adjusted terms, though capturing that edge reliably tends to require automation for rebalancing.

Building a Polymarket Market Screener with the Assymetrix SDK

The /sdk/markets endpoint returns the fields a screener needs directly: market_id, category, status, 24h_volume, maker_liquidity, and an outcomes[] array.

To build the screener:

• Authenticate with your API key, then pull markets in paginated batches rather than one bulk request.

• Normalize category and status labels against a fixed enum before storing, since raw labels shift across market versions.

• Store incremental updates keyed on market_id and a last_updated timestamp so alerts trigger only on real changes.

A workable filter sequence: start broad (all active markets), narrow to your target categories, then apply a volume floor (say, above $50,000 in 24-hour volume) to surface only markets with enough liquidity to trade. Review the shortlist manually before wiring it into any automated signal, since category taxonomies still need occasional human judgment. The Polymarket data analysis guide walks through a fuller implementation with code examples.

Practical habits that separate production-grade quants from hobbyists

Version every dataset snapshot before you touch it, or you’ll never reproduce a backtest six months later. Manage alert fatigue aggressively: a screener that pings you fifty times a day gets ignored by day three. Run peer review on signal logic the same way you’d review a pull request, and check for oracle dispute noise before trusting any resolution-driven price move.

How Assymetrix Helps You Move From Raw Events to Production Signals

Everything covered above, event mapping, cleaning rules, wallet scoring, cross-venue checks, requires an underlying data layer that doesn’t break at scale. Assymetrix indexes over 900 million Polymarket on-chain events into a normalized schema, alongside full wallet-level trading history at trade-level granularity.

That means you skip the dedupe logic, the USDC contract allowlisting, and the token ID mapping described earlier in this guide. Cross-venue data against Kalshi and Limitless comes through the same integration, so a smart-money score or arbitrage signal doesn’t require stitching together three separate vendor schemas. The Data API documentation covers both streaming and REST delivery modes for teams running production pipelines.

Start with the /sdk/markets endpoint to build your own screener, or request a sample dataset directly at Data to test wallet scoring against your own P&L attribution model before committing to a subscription tier.

Sources

• Microstructure Evidence from the Polymarket Order Book

• Top 10 Polymarket Trading Strategies in 2026 (With Examples)

• Step By Step Guide To On-Chain Analytics On Polymarket | PredictEngine | PredictEngine

This article is general information, not a substitute for advice from a qualified financial advisor. Consult a qualified financial professional about your own circumstances before acting on anything here.

FAQ

Does Polymarket run on-chain?

Settlement runs on-chain through the Exchange contract on Polygon, using conditional tokens and USDC, but order creation and matching happen off-chain before settling on-chain.

What database does Polymarket use?

Polymarket doesn’t publish its internal database architecture; what matters for analysts is the on-chain settlement layer, which any indexer, Dune, Goldsky, Allium, or the Assymetrix Data API, can query directly.

Can you scrape Polymarket data?

You can pull data through Polymarket’s public API and WebSocket feeds, or index the underlying Polygon contract events directly, rather than scraping the front end, which is unreliable for trade-level granularity.

How does Polymarket work on the blockchain?

Orders are matched off-chain by Polymarket’s operator, then settled on-chain as conditional token transfers and USDC movements, with market resolution triggering redeem events that pay out winning positions.

Which data source is best for real-time Polymarket signals?

Dune works well for exploratory research, but production signals that trade on latency need a normalized, low-latency feed like the Assymetrix Data API, which delivers wallet-level history and cross-venue coverage through one integration.