BTCBTC$65,160+2.67%|
ETHETH$1,825.67+4.78%|
USDTUSDT$0.99957+0.01%|
BNB$595.5700+3.73%|
USDCUSDC$0.99974+0.01%|
XRPXRP$0.96933+8.03%|
SOLSOL$72.3300+4.76%|
TRXTRX$0.30502-0.35%|
FIGR_HELOCFIGR_HELOC$1.0570+0.65%|
HYPEHYPE$68.2000+9.01%|
ZECZEC$907.2100+8.18%|
XMRXMR$494.9000+7.65%|
DOGEDOGE$0.05931+5.82%|
USDSUSDS$0.99976+0.04%|
LEOLEO$9.1800+1.34%|
WBTWBT$63.0600+2.34%|
LINKLINK$9.2600+6.66%|
ADAADA$0.15428+6.64%|
XLMXLM$0.14103+6.95%|
USDEUSDE$0.99957-0.01%|
DAIDAI$0.99966-0.02%|
BCHBCH$209.5700+5.61%|
NEARNEAR$3.2100+8.93%|
LTCLTC$45.3800+3.49%|
CCCC$0.08385+10.83%|
AVAXAVAX$7.2500+3.32%|
UNIUNI$5.1600+9.21%|
XAUTXAUT$3,839.64+1.19%|
USD1USD1$0.99860+0.04%|
GRAMGRAM$1.0660+3.69%|
BTCBTC$65,160+2.67%|
ETHETH$1,825.67+4.78%|
USDTUSDT$0.99957+0.01%|
BNBBNB$595.5700+3.73%|
USDCUSDC$0.99974+0.01%|
XRPXRP$0.96933+8.03%|
SOLSOL$72.3300+4.76%|
TRXTRX$0.30502-0.35%|
FIGR_HELOCFIGR_HELOC$1.0570+0.65%|
HYPEHYPE$68.2000+9.01%|
ZECZEC$907.2100+8.18%|
XMRXMR$494.9000+7.65%|
DOGEDOGE$0.05931+5.82%|
USDSUSDS$0.99976+0.04%|
LEOLEO$9.1800+1.34%|
WBTWBT$63.0600+2.34%|
LINKLINK$9.2600+6.66%|
ADAADA$0.15428+6.64%|
XLMXLM$0.14103+6.95%|
USDEUSDE$0.99957-0.01%|
DAIDAI$0.99966-0.02%|
BCHBCH$209.5700+5.61%|
NEARNEAR$3.2100+8.93%|
LTCLTC$45.3800+3.49%|
CCCC$0.08385+10.83%|
AVAXAVAX$7.2500+3.32%|
UNIUNI$5.1600+9.21%|
XAUTXAUT$3,839.64+1.19%|
USD1USD1$0.99860+0.04%|
GRAMGRAM$1.0660+3.69%|
Dune — Fernando Molina Polymarket Markets Data (@fergmolina)
Tool / APITier-1Analytics dashboardVerified

Dune — Fernando Molina Polymarket Markets Data (@fergmolina)

Dune's own case study for its LiveFetch functions: Fernando Molina's board pulls Polymarket's Gamma API into SQL so volume can be attributed to a market and even a specific outcome.

Visit website

Key Facts

CategoryAnalytics dashboard
AccessFree to view and copy on Dune with no account needed. Because the board pulls live data from Polymarket's Gamma API inside its queries, copying and running it yourself consumes Dune execution credits and hits per-execution API-call limits — running your own follows Dune's plans ($65/mo Analyst, $349/mo Plus).
Venues CoveredPolymarket (Polygon on-chain trades joined to Gamma API market metadata, Events and Markets + Answers)
Data ConfidenceVerified
Last Reviewed30 Sep 2026

What It Does

The dashboard Dune itself used to showcase LiveFetch, the SQL functions that send HTTP requests to APIs from inside a query. Fernando Molina, a data engineer who publishes on X as @fergmolina, wrote queries that call Polymarket's Gamma Markets API directly, parse the returned JSON, and join it to on-chain trades so analysis can move past Polymarket as one lump: volume, trades and users are broken out per Event, then per Market and per Answer, with the Gamma API supplying the market ID, question, outcomes, CLOB token IDs, categorisation, rules and timestamps that live off-chain. The problem it solves is concrete — Polymarket settles on Polygon but keeps market descriptions and rules off-chain, so matching a traded token back to the market and outcome it belongs to normally means running an external script and manually refreshing a mapping table, which scales badly and misses markets that open later. The board is candid about its own limits: Gamma serves at most 100 markets per call so the queries page with an offset, markets under $50,000 volume are filtered out to cut noise and stay inside per-execution API limits, markets missing from the API read 'No Data', a materialised view refreshes daily, and volume and user charts show 20 and 10 data points respectively while the tables carry the full population. Users are distinct wallets grouped by Event or Market, so the same wallet can appear under more than one. For aggregated Polymarket totals it points readers to the rchen8 dashboard instead.

Overview

What this board is

Dune — Fernando Molina Polymarket Markets Data (@fergmolina) is a public Dune dashboard that reads Polymarket's market metadata from an API inside a SQL query and joins it to on-chain trades, so trading volume can be traced back to the individual market — and the individual outcome — it belongs to. It is the dashboard Dune itself uses to demonstrate LiveFetch, the set of SQL functions that make HTTP requests from inside a query.

The author is Fernando Molina, a data engineer who publishes on X as @fergmolina. The board is free to open: no wallet, no exchange account and no paid plan are needed to read it.

The problem it was built to solve

Polymarket settles trades on Polygon, but the questions, outcomes, rules, categories and timestamps that give those trades meaning live off-chain, in Polymarket's Gamma Markets API. A fill therefore arrives as a token ID and a size, with nothing in the on-chain record saying which market it belongs to or which side of the question was bought.

The conventional fix is an external script: call the API, download the market list, build a mapping table of token IDs to markets, then join it to the trades. That approach has two structural weaknesses. The mapping has to be rebuilt and reloaded every time a market is created or resolved, so markets opened after the last refresh stay invisible; and the mapping table becomes an asset someone has to maintain, document and trust.

This board removes the maintenance step. Because the API is called from inside the query, the mapping is generated at execution time — a market created since the last run is picked up by the next one, with nobody editing a lookup table.

What it shows that a venue-wide chart cannot

A single 'Polymarket volume' number answers a question almost nobody is asking. Research, reporting and trading decisions need to know which market moved, and often which answer inside it. Volume, trades and distinct wallets are broken out at three levels — first by Event, then by Market, then by Answer — so a reader can see that a spike came from one outcome rather than from the venue as a whole.

In practice that means the board can answer:

  • Which market inside a multi-market event is actually carrying the volume?
  • How is activity split across the possible answers to a single question?
  • Is participation in a market broad, or concentrated in a small set of wallets?
  • How does activity compare across events in the same category?

Transparency about its own limits

Unusually for a public dashboard, the constraints are stated on the board itself: Polymarket's API returns at most 100 markets per call, so the queries page through it with an offset; markets below $50,000 in volume are filtered out to cut noise and stay inside the per-execution API limits; markets the API does not return are labelled No Data rather than dropped silently; a materialised view refreshes daily; and the charts are deliberately trimmed while the tables underneath carry the full population. Each of those is documented in Method Notes & Limitations below, and they are the first thing to read before quoting a number from the board.

Who it is for

  • Prediction-market researchers who need per-market and per-outcome attribution rather than a venue total.
  • Trading and data teams using prediction-market activity as an alternative-data signal.
  • Analysts and journalists who need to cite a market-level figure and show where it came from.
  • Dune users who want a working reference implementation of LiveFetch — the queries are public and can be copied.

What it is not

This is an analytics board, not a venue: it does not take orders, hold funds or quote prices. Bitnxt is not affiliated with Dune, Polymarket or the dashboard's author. For whole-venue Polymarket totals the board itself points readers to a separate rchen8 dashboard; the value here is the grain below it.

How It Works

Step 1 — Call the API from inside the query (LiveFetch)

Dune's LiveFetch functions issue an HTTP request from within SQL and return the response body as text. This board uses them to read Polymarket's Gamma Markets API in the same query that reads chain data, instead of in a separate pipeline that has to be scheduled and reloaded.

The documentation defines the functions as http_get(url), http_post(url, body) and http_post(url, body, headers), each returning text. Parameters and credentials can be templated into the URL, and the response can be parsed with Dune's JSON functions in the same query — the documented examples run a parametrised GET per contract address, use a call as a static filter inside a subquery, and post JSON-RPC with a Content-Type header.

Step 2 — Parse the off-chain payload in SQL

The JSON returned by Gamma is extracted into columns inside the query: market ID, question, the possible outcomes, the CLOB token IDs behind them, categorisation, rules and timestamps. This is the step that turns a token ID sitting in a trade into a readable market and answer.

Step 3 — Join that metadata to on-chain trades

The parsed metadata is joined to Polymarket's on-chain trades on Polygon. Each fill inherits the market and the outcome it belongs to, so volume, trade counts and wallets can all be grouped by market rather than by anonymous token.

Step 4 — Group by Event, then Market, then Answer

The board exposes three levels of grain: an Event is the umbrella question — an election, a race, an award; a Market is one tradable question under it; an Answer is one possible outcome of that market. Volume and trades are broken out at each level.

Paging: 100 markets per call

Gamma serves a maximum of 100 markets per request, well below the number of live markets. The queries therefore page the API with an offset and repeat the call until the pages are exhausted. That is the mechanism behind the board's coverage — and the reason a market can be absent even though it exists on-chain.

The $50,000 volume floor

Markets under $50,000 in volume are excluded. The board gives two reasons: it keeps long-tail noise out of the tables, and it keeps each execution inside the API-call limits that apply when a query makes live API calls. The trade-off is that the smallest and newest markets are not part of the board's totals.

Refresh model: charts trimmed, tables complete

The cached layer is a materialised view that refreshes daily, and the charts and tables read from it at different levels of detail:

LayerFreshnessPopulationHow to read it
Materialised viewRefreshed dailyEvery market returned by the API that clears the $50,000 floorThe base for everything else on the board
Volume chartRefreshed daily20 data pointsTrend indicator, not a full history
Wallet chartRefreshed daily10 data pointsTrend indicator only
TablesRefreshed dailyFull population of the viewUse these for any figure you intend to cite or publish

What each metric family measures

  • Volume — notional traded, attributed to the market and the answer it was traded in.
  • Trades — the number of fills behind that volume.
  • Wallets — distinct addresses that traded, grouped by Event or by Market. A participation measure, not a count of people.

Method Notes & Limitations

Where the numbers come from

Two sources, joined: Polymarket's on-chain trades on Polygon, and Polymarket's Gamma Markets API for market metadata. If the API does not return a market — because it fell outside the retrieved pages, or is not exposed at all — the row is shown as No Data instead of being silently removed, so a gap stays visible as a gap.

Known scope limits

  • Markets below $50,000 in volume are outside the board by design.
  • Coverage depends on the API's 100-market page size and the offset paging around it; a market the API no longer serves cannot be reconstructed from the metadata side.
  • The volume chart is trimmed to 20 points and the wallet chart to 10; only the tables carry the full population.
  • The cached layer is a materialised view refreshed daily, so the cached results are only as current as the last refresh.

How wallets are counted

Users are distinct wallets, grouped by Event or by Market. One person can trade from several wallets, and one wallet that has traded in more than one market appears under each of them. Read the counts as participation, and do not sum them across groups — the same address would be counted more than once.

Cost and limits if you run it yourself

Viewing and copying the board is free. Executing the queries yourself is not: runs consume Dune credits and each execution is subject to per-execution API-call limits, because every run makes live calls to Polymarket's API. Dune's published self-serve plans at the time of writing are Free ($0, one seat, view and copy), Analyst ($65/month, 3 seats, 4,000 credits a month, 40 API calls per minute) and Plus ($349/month, 10 seats, 25,000 credits a month, 200 API calls per minute); annual billing is around 15% cheaper, and extra credits are priced at $0.016 and $0.014 respectively. Enterprise is quoted separately and adds commercial licensing, Datashare to Snowflake, BigQuery, Databricks and S3, and SLAs.

Licensing

Dune's self-serve plans are licensed for internal use. Commercial redistribution — republishing or embedding the dataset in a paid product — requires the commercial licence that comes with the Enterprise plan. Quoting a figure with attribution is a different matter from redistributing a dataset, so confirm the terms with Dune directly before publishing at scale.

Editorial note

Bitnxt is not affiliated with Dune, Polymarket or the dashboard's author. This page is a reader's guide to a public dashboard, not a substitute for it: the underlying figures change as the board refreshes, so verify any number against the live board and its own notes before relying on it. This page carries no trading links, no exchange referrals and no investment advice.

Venues Covered

Polymarket (Polygon on-chain trades joined to Gamma API market metadata, Events and Markets + Answers)

Access & Pricing

Free to view and copy on Dune with no account needed. Because the board pulls live data from Polymarket's Gamma API inside its queries, copying and running it yourself consumes Dune execution credits and hits per-execution API-call limits — running your own follows Dune's plans ($65/mo Analyst, $349/mo Plus).

Frequently Asked Questions

Sources & Verification

The factual claims on this page were checked against the sources below.

Bitnxt uses cookies to run the site, understand how it is used, and measure ads. You can accept or decline below, and change your choice any time in our Privacy Policy.