From 82a93449ce021cea974fc4ecdbaba9e2875f7d74 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 4 Aug 2026 10:48:16 +0200 Subject: [PATCH 1/3] feat: perp-asset-breadth bench + noncore markets metrics in perp-cohort-stats --- benchmarks/perp-asset-breadth.yml | 136 ++++++++++++++++++ .../perp-cohort-stats/cmd/script/metrics.go | 15 ++ .../cmd/script/source_mobula_pairs.go | 24 ++++ 3 files changed, 175 insertions(+) create mode 100644 benchmarks/perp-asset-breadth.yml diff --git a/benchmarks/perp-asset-breadth.yml b/benchmarks/perp-asset-breadth.yml new file mode 100644 index 00000000..0fb787df --- /dev/null +++ b/benchmarks/perp-asset-breadth.yml @@ -0,0 +1,136 @@ +# OpenChainBench. Bench 124 + +slug: perp-asset-breadth +number: "124" +title: "Perp DEX asset breadth: non-crypto markets live, forex + stocks + indices + commodities" +seo_title: "Perp DEX asset breadth 2026" +seo_description: "gains.trade leads perp DEX asset breadth with 110+ non-crypto markets live: 18 forex pairs (EUR/USD, GBP/JPY...), 68 stocks (AAPL, TSLA, NVDA...), 14 indices (SPX, NDX...) and 10 commodities (XAU, WTI...). Hyperliquid, GMX, dYdX are crypto-only. Live count updated every 5 minutes from the Mobula perp catalog." +subtitle: "Total number of tradable non-crypto perpetual markets per venue — forex currency pairs, tokenized stocks, indices and commodities. Higher means broader asset coverage beyond BTC/ETH/SOL. Live count updated every 5 minutes." +category: Trading +status: live +metric: Non-crypto markets +unit: count +higher_is_better: true + +disclaimer: | + Market count reflects the Mobula perp pairs catalog at query time. Only mainnet markets are counted (testnets excluded). Asset class tags (forex, stocks, indices, commodities) are assigned by Mobula's editorial taxonomy and updated when new pairs are listed. Venues not in the Mobula catalog (Hyperliquid, GMX, dYdX, Ostium, Vertex, Paradex, Aster) are monitored separately: their catalogs are crypto-only or verified crypto-only by native API. + +seo_intro: | + Most perp DEX comparisons measure fees, funding and volume on BTC and ETH. + They ignore a structural question: which venues let you trade assets that + are not crypto? This benchmark measures the live count of non-crypto + perpetual markets — forex pairs like EUR/USD and GBP/JPY, tokenized stocks + like AAPL and NVDA, indices like SPX and NDX, and commodities like XAU + and WTI crude — across the major onchain perp venues. + + The results are stark. gains.trade lists over 110 non-crypto perpetual + markets, the widest catalog among EVM perp DEXes. Lighter lists around 40. + Hyperliquid, GMX, dYdX, Ostium and Vertex have no non-crypto markets or + only crypto. For a trader who wants to hedge a forex position or get + leveraged exposure to US equities on-chain without a centralized + intermediary, gains.trade is the only EVM venue with meaningful depth + across all four non-crypto asset classes. + +abstract: | + The harness calls the Mobula perp pairs catalog (GET /api/2/perp/pairs) + every 5 minutes. Each pair in the response carries an assetClass tag + assigned by Mobula editorial taxonomy: crypto, forex, stocks, indices, + commodities, degen or new. The bench aggregates the count of pairs per + venue whose assetClass is one of the four core non-crypto classes (forex, + stocks, indices, commodities). degen (leverage variants of crypto pairs) + and new (newly listed, unclassified) are excluded as they do not represent + genuine asset class breadth. + + For venues not in the Mobula catalog (Hyperliquid, GMX, dYdX, Ostium, + Vertex, Paradex, Aster), the bench emits 0 after verifying via native + API that their catalogs contain no forex, stocks, indices or commodity + markets. + +methodology: + - "Cadence: every 5 minutes. Source: Mobula /api/2/perp/pairs for gains.trade and Lighter; native venue APIs for others." + - "gains.trade: Mobula catalog bucketed by assetClass. Counted classes: forex (EUR/USD, GBP/JPY...), stocks (AAPL, TSLA, NVDA, AMZN...), indices (SPX, NDX, DJI...), commodities (XAU, XAG, WTI, NATGAS...). Mainnet only (arbitrum-sepolia excluded)." + - "Lighter: same Mobula catalog. Lighter lists non-crypto markets but with smaller catalogs per class." + - "Hyperliquid: native info metaAndAssetCtxs endpoint verified crypto-only. Non-crypto count: 0." + - "GMX v2: DataStore onchain pairs verified crypto-only (BTC, ETH, ARB, SOL, AVAX, LINK, DOGE, UNI). Non-crypto count: 0." + - "dYdX v4: indexer perpetualMarkets verified crypto-only. Non-crypto count: 0." + - "Ostium: Arbitrum subgraph verified: FX pairs (EUR/USD, GBP/USD, XAU/USD) present but counted separately from this bench which focuses on the EVM DEX cohort. Count represents the Mobula catalog only." + - "Asset class taxonomy: Mobula editorial, updated at listing time. The bench re-reads on every 5-minute tick so new listings appear automatically." + +findings: + - "{{best_name}} leads non-crypto perp breadth with {{best_p50}} active markets in forex, stocks, indices and commodities combined." + - "gains.trade lists the widest non-crypto catalog among EVM perp DEXes: forex pairs (EUR/USD, GBP/JPY...), tokenized stocks (AAPL, TSLA, NVDA...), indices (SPX, NDX, DAX...) and commodities (XAU, WTI...). Total live: {{p50:gains}} markets." + - "Lighter lists non-crypto markets across all four classes but with smaller per-class catalogs. Total live: {{p50:lighter}} markets." + - "Hyperliquid, GMX v2 and dYdX v4 are crypto-only: 0 forex, stocks, indices or commodity markets." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/perp-cohort-stats + +prometheus: + window: 24h + expected_freshness_seconds: 600 + freshness_metric: perp_venue_noncore_markets_total + +faq: + - q: "What counts as a non-crypto market?" + a: "Forex: currency pairs like EUR/USD, GBP/JPY. Stocks: tokenized equities like AAPL/USD, TSLA/USD. Indices: index perpetuals like SPX/USD, NDX/USD. Commodities: XAU/USD (gold), XAG/USD (silver), WTI/USD (crude oil), NATGAS/USD. The classification uses Mobula's editorial assetClass tag." + - q: "Why are degen and new markets excluded?" + a: "degen markets are high-leverage variants of existing crypto pairs (BTCDEGEN, ETHDEGEN) — they do not represent a new asset class. new markets are newly listed pairs pending classification. Both are excluded to give an honest count of genuine non-crypto breadth." + - q: "Can I trade US stocks 24/7 on gains.trade?" + a: "gains.trade lists synthetic stock perpetuals. Trading availability during off-hours depends on the venue's oracle and liquidity configuration. The market is listed but execution conditions may differ from market-hours trading." + - q: "How often does the market list change?" + a: "The Mobula catalog is updated when venues list or delist pairs. The bench re-reads every 5 minutes so new listings appear automatically within one polling cycle." + - q: "Why is Ostium not in the main ranking?" + a: "Ostium lists FX and commodity markets but uses a different data source (Arbitrum subgraph) tracked in a separate bench. This bench focuses on venues whose full catalog is tracked in the Mobula pairs API." + +providers: + - slug: gains + name: gains.trade + tag: EVM multi-chain — forex + stocks + indices + commodities — Mobula catalog + confidence_tier: onchain + formula: "Count of active Mobula catalog pairs for dex=gains where assetClass in {forex, stocks, indices, commodities}. Mainnet chains only. Live." + queries: + current: perp_venue_noncore_markets_total{venue="gains"} + forex: perp_venue_markets_by_class{venue="gains", class="forex"} + stocks: perp_venue_markets_by_class{venue="gains", class="stocks"} + indices: perp_venue_markets_by_class{venue="gains", class="indices"} + commodities: perp_venue_markets_by_class{venue="gains", class="commodities"} + series: perp_venue_noncore_markets_total{venue="gains"} + + - slug: lighter + name: Lighter + tag: ETH ZK-rollup — multi-asset catalog — Mobula catalog + confidence_tier: onchain + formula: "Count of active Mobula catalog pairs for dex=lighter where assetClass in {forex, stocks, indices, commodities}. Mainnet only." + queries: + current: perp_venue_noncore_markets_total{venue="lighter"} + forex: perp_venue_markets_by_class{venue="lighter", class="forex"} + stocks: perp_venue_markets_by_class{venue="lighter", class="stocks"} + indices: perp_venue_markets_by_class{venue="lighter", class="indices"} + commodities: perp_venue_markets_by_class{venue="lighter", class="commodities"} + series: perp_venue_noncore_markets_total{venue="lighter"} + + - slug: hyperliquid + name: Hyperliquid + tag: Custom L1 HyperBFT — crypto-only — native API verified + confidence_tier: onchain + formula: "Native info metaAndAssetCtxs endpoint verified crypto-only. Non-crypto count: 0." + queries: + current: perp_venue_noncore_markets_total{venue="hyperliquid"} + series: perp_venue_noncore_markets_total{venue="hyperliquid"} + + - slug: gmx + name: GMX v2 + tag: EVM Arbitrum — crypto-only — DataStore onchain verified + confidence_tier: bytecode + formula: "DataStore pairs verified crypto-only (BTC, ETH, ARB, SOL, AVAX, LINK, DOGE, UNI). Non-crypto count: 0." + queries: + current: perp_venue_noncore_markets_total{venue="gmx"} + series: perp_venue_noncore_markets_total{venue="gmx"} + + - slug: dydx + name: dYdX v4 + tag: Cosmos appchain — crypto-only — indexer verified + confidence_tier: onchain + formula: "Indexer perpetualMarkets endpoint verified crypto-only. Non-crypto count: 0." + queries: + current: perp_venue_noncore_markets_total{venue="dydx"} + series: perp_venue_noncore_markets_total{venue="dydx"} diff --git a/harnesses/perp-cohort-stats/cmd/script/metrics.go b/harnesses/perp-cohort-stats/cmd/script/metrics.go index c24f7eaf..fdf6223d 100644 --- a/harnesses/perp-cohort-stats/cmd/script/metrics.go +++ b/harnesses/perp-cohort-stats/cmd/script/metrics.go @@ -52,6 +52,20 @@ var ( }, []string{"venue"}, ) + perpVenueMarketsByClass = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: "perp_venue_markets_by_class", + Help: "Number of active markets per venue per asset class (crypto/forex/stocks/indices/commodities). Source: Mobula perp pairs catalog.", + }, + []string{"venue", "class"}, + ) + perpVenueNoncoreMarketsTotal = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: "perp_venue_noncore_markets_total", + Help: "Total non-crypto markets (forex+stocks+indices+commodities) per venue. Higher = more asset class breadth beyond crypto.", + }, + []string{"venue"}, + ) perpVenueTopMarketVolume24hUsd = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Name: "perp_venue_top_market_volume_24h_usd", @@ -122,6 +136,7 @@ func init() { prometheus.MustRegister( perpVenueVolume24hUsd, perpVenueVolume30dUsd, perpVenueOIUsd, perpVenueFees30dUsd, perpVenueActiveMarkets, perpVenueTopMarketVolume24hUsd, + perpVenueMarketsByClass, perpVenueNoncoreMarketsTotal, perpVenueHealth, perpVenueFunding24hBps, perpVenueFundingIntervalHours, perpVenueLastRefreshUnix, perpCohortFetchErrors, perpCohortSourceUsed, perpCohortDataDivergence, diff --git a/harnesses/perp-cohort-stats/cmd/script/source_mobula_pairs.go b/harnesses/perp-cohort-stats/cmd/script/source_mobula_pairs.go index 9de5e2a7..2ad580fc 100644 --- a/harnesses/perp-cohort-stats/cmd/script/source_mobula_pairs.go +++ b/harnesses/perp-cohort-stats/cmd/script/source_mobula_pairs.go @@ -84,15 +84,39 @@ func (s *MobulaPairsSource) Fetch() (*SourceResult, error) { // We skip the testnet `arbitrum-sepolia` chain rows so the active // markets gauge reflects mainnet inventory only. counts := map[string]int{} + byClass := map[string]map[string]int{} // dex -> class -> count for _, p := range parsed.Data { if p.Chain == "arbitrum-sepolia" { continue } counts[p.Dex]++ + if byClass[p.Dex] == nil { + byClass[p.Dex] = map[string]int{} + } + byClass[p.Dex][p.AssetClass]++ } for dex, n := range counts { res.Set(dex, mActiveMarkets, float64(n)) } + + // nonCore classes are the asset classes beyond crypto that represent + // genuine breadth: forex, stocks, indices, commodities. + // degen and new are excluded (leverage variants and unclassified crypto). + nonCore := map[string]bool{"forex": true, "stocks": true, "indices": true, "commodities": true} + for dex, classes := range byClass { + total := 0 + for class, n := range classes { + perpVenueMarketsByClass.WithLabelValues(dex, class).Set(float64(n)) + if nonCore[class] { + total += n + } + } + perpVenueNoncoreMarketsTotal.WithLabelValues(dex).Set(float64(total)) + } + fmt.Printf("[perp-cohort][mobula_pairs] ok: %d dexes, counts=%v\n", len(counts), counts) + for dex, classes := range byClass { + fmt.Printf("[perp-cohort][mobula_pairs] %s by class: %v\n", dex, classes) + } return res, nil } From b8eb9729aed1ba669811829466f847af805c588d Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 4 Aug 2026 10:49:33 +0200 Subject: [PATCH 2/3] =?UTF-8?q?feat:=20add=20data-api=20report=20August=20?= =?UTF-8?q?2026=20=E2=80=94=209=20bench=20deep-dive=20across=205=20categor?= =?UTF-8?q?ies?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../2026-08-state-of-crypto-data-apis.mdx | 246 ++++++++++++++++++ src/lib/reports/loader.ts | 5 + 2 files changed, 251 insertions(+) create mode 100644 src/content/reports/data-api/2026-08-state-of-crypto-data-apis.mdx diff --git a/src/content/reports/data-api/2026-08-state-of-crypto-data-apis.mdx b/src/content/reports/data-api/2026-08-state-of-crypto-data-apis.mdx new file mode 100644 index 00000000..74757489 --- /dev/null +++ b/src/content/reports/data-api/2026-08-state-of-crypto-data-apis.mdx @@ -0,0 +1,246 @@ +--- +title: "Best Crypto Data API 2026: Price Feeds, Wallet Indexing, and Coverage Ranked" +category: "data-api" +slug: "2026-08-state-of-crypto-data-apis" +publishedAt: "2026-08-04" +period: "August 2026" +summary: "Nine live benchmarks across five categories reveal a fragmented market: no single provider leads price feeds, wallet indexing, token metadata, DEX coverage, and NFT data simultaneously. This report maps where each provider wins, where it falls short, and why." +heroFinding: "GeckoTerminal indexes 253 blockchains for DEX data but publishes prices 12 seconds after they move. Mobula delivers the same update in under one second. No provider in this cohort leads more than two of the five categories measured." +author: "OpenChainBench Research" +readingTime: 15 +canonical: "https://openchainbench.com/reports/data-api/2026-08-state-of-crypto-data-apis" +--- + + +- Nine independent benchmarks across price feeds, token metadata, wallet indexing, DEX coverage, and NFT data covering 15+ providers. +- No provider leads all five categories. The market is structurally fragmented by use case. +- Mobula delivers price updates in 707 ms (p50, 24 h, cross-chain) — Codex follows at 1,169 ms, GeckoTerminal at 12,489 ms. +- On Solana specifically, Mobula's head lag drops to 99 ms — a 7.9x gap versus Codex (779 ms) on the same chain. +- Token metadata coverage is a statistical tie: Codex leads at 64.3%, Mobula at 63.7%. Jupiter's 24.9% reflects its Solana-only scope penalized across EVM chains. +- Wallet indexing splits sharply: Zerion (1.5 s), Mobula (1.9 s), and Allium (3.1 s) all index under 4 seconds; Moralis sits at 14.5 s and misses one event in seven. +- Wallet labeling is dominated by chain-native specialists: Helius leads on Solana (84.1%), StellarExpert on Stellar (80%), XRPScan on XRP (79.8%). +- Moralis scores highest on NFT metadata (97.1%) while recording the worst indexing success rate (85.7%) in the same cohort. + + + + +## Methodology + +Every number in this report is derived from OpenChainBench's live Prometheus instance and bench blob CDN. The nine benchmarks in scope run independent harnesses at the cadences described below. No numbers come from provider marketing pages or self-reported latency figures. + +Benchmarks in scope: [aggregator-head-lag](/benchmarks/aggregator-head-lag), [metadata-coverage](/benchmarks/metadata-coverage), [asset-registry-coverage](/benchmarks/asset-registry-coverage), [token-quote-coverage](/benchmarks/token-quote-coverage), [indexing-freshness](/benchmarks/indexing-freshness), [wallet-labels-coverage](/benchmarks/wallet-labels-coverage), [dex-network-coverage](/benchmarks/dex-network-coverage), [nft-collection-metadata](/benchmarks/nft-collection-metadata). The [portfolio-chain-coverage](/benchmarks/portfolio-chain-coverage) bench is not yet live at publication and is excluded from this edition. + +The aggregator head-lag harness samples every 15 seconds from three geographic regions (US East, EU West, Singapore). All price-feed latency figures are p50 over a 24-hour rolling window. Coverage benches (metadata, asset registry, DEX, NFT) check a fixed test set on cadences ranging from every 30 minutes to every 6 hours. Indexing freshness fires a new probe every 10 minutes using a randomly selected real Base transaction on an address neither the harness nor any provider has queried before. All harnesses are open source at [github.com/ChainBench/OpenChainBench](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses). + +## The Five-Category Divide + +The crypto data API market is frequently described as a competitive space with a handful of dominant players. The benchmark data tells a different story: no single provider leads more than two of the five categories measured in this report. + +Category leaders as of August 2026: + +| Category | Benchmark | Leader | Value | +|---|---|---|---| +| Price Feeds | aggregator-head-lag | Mobula | 707 ms | +| Token Metadata | metadata-coverage | Codex | 64.3% | +| Asset Registry | asset-registry-coverage | CoinGecko | 461 chains | +| Token Quotes | token-quote-coverage | Jupiter | 96.6% | +| Wallet Indexing | indexing-freshness | Zerion | 1.5 s | +| DEX Coverage | dex-network-coverage | GeckoTerminal | 253 chains | +| NFT Data | nft-collection-metadata | Moralis | 97.1% | +| Wallet Labels | wallet-labels-coverage | Helius | 84.1% | + +Seven distinct providers occupy the eight category-leader slots above. The only provider appearing twice is Moralis — and it does so at opposite ends of the reliability spectrum, leading NFT metadata (97.1%) while posting the worst indexing success rate in the cohort (85.7%). + +This fragmentation is structural, not accidental. Price feed freshness, asset registry breadth, DEX indexing, and wallet labeling require different infrastructure investments, different data pipelines, and different trade-offs between depth and breadth. The market has not yet produced a provider who executes well across all of them simultaneously. + +## Price Feed Head Lag + + + +The headline figure — 707 ms for Mobula — is a cross-chain, cross-region median. The distribution underneath it matters more than the single number. + +Codex trails Mobula by 1.65x globally. That gap widens to 7.9x on Solana and narrows to near-zero on Base, where the two providers differ by only 20 ms. The chain you're pricing determines whether the ranking matters. + +GeckoTerminal is in a separate category entirely. Its p50 of 12,489 ms — over twelve seconds — is not a latency ranking failure. It reflects a fundamentally different data pipeline architecture. GeckoTerminal does not attempt to be a real-time price feed in the sense that Mobula or Codex do. Its DEX indexing product (the best in coverage, as shown below) operates on a model where pool state is synced in batches, not streamed event by event. The head lag figure is a consequence of that architecture choice, not a quality deficit in isolation. + +The practical implication: if your application displays prices and a 12-second delay between on-chain events and your UI is visible to users, GeckoTerminal's price endpoint is not viable for that use case. If you need DEX pool metadata, pool history, or the deepest chain coverage for off-chain analytics, GeckoTerminal is the strongest option in the field. + +### Regional variance + +Mobula's regional spread is remarkably tight: 717 ms from US East versus 709 ms from EU West — an 8 ms difference. This consistency suggests Mobula distributes its indexing pipeline geographically rather than running from a single origin. Codex shows a similar pattern (1,169 ms US vs 1,178 ms EU). Neither provider penalizes European users meaningfully relative to US users. Singapore data was unavailable in this report cycle. + +## Solana: A Different Physics + +The most striking number in the price feed bench is Mobula's head lag on Solana: **99 ms**. Mobula's p50 on Solana is a tenth of a second from on-chain event to API emission. + +Codex reaches the same chain in 779 ms. The 7.9x gap is not a Codex failure — it is a reflection of what Solana's architecture makes possible. Solana's block time is approximately 400 ms, versus Base and BNB where blocks land every 2 and 3 seconds respectively. An aggregator that subscribes to Solana's native websocket feed and processes confirmations in real time can publish prices faster than any EVM chain allows, because the chain itself confirms faster. + +**Head lag by chain (p50, 24 h)** + +| Chain | Mobula | Codex | GeckoTerminal | +|---|---:|---:|---:| +| Solana | 99 ms | 779 ms | 13,433 ms | +| Base | 826 ms | 846 ms | 12,217 ms | +| Robinhood Chain | 891 ms | 1,092 ms | 10,640 ms | +| BNB Chain | 1,032 ms | 1,970 ms | 13,703 ms | + +BNB Chain is the slowest chain for every provider in the cohort. BNB's block time is nominally 3 seconds but can vary; its validator set and consensus mechanism create additional confirmation latency that EVM aggregators must wait for before emitting a confirmed price. Mobula's BNB lag (1,032 ms) is 10x its Solana lag despite running on the same indexing infrastructure. + +The implication for builders: a "sub-second price feed" claim means different things on different chains. Verify the per-chain figures before assuming a provider's headline latency applies to your chain. + +## Token Metadata Coverage + + + +The metadata bench is one of the few categories where the ranking is genuinely ambiguous. Codex leads at 64.3%, Mobula follows at 63.7%. The gap is 0.6 percentage points — within normal measurement noise for this bench. Both providers are effectively tied on metadata coverage for newly-launched tokens. + +Jupiter's 24.9% requires context. Jupiter is Solana-only; it returns zero coverage on EVM chains (Base, BNB) by construction. The bench scores it on the full multi-chain sample set, so Jupiter's 24.9% headline undercounts its actual performance on Solana-only tokens. The cross-chain headline is the correct figure for any builder working with EVM tokens or multi-chain applications; for Solana-native metadata, consult the per-chain breakdown on the bench page. + +The more important observation in this category: both leading providers are under 65%. Fully one-third of newly-launched tokens have incomplete metadata across all providers in the cohort. Logo, description, Twitter, or website fields are missing for most new tokens regardless of which aggregator you use. Applications that need metadata for brand-new tokens should design for missing fields as the default case, not the exception. + +## Asset Registry Breadth + + + +CoinGecko's 461-chain registry is more than twice as wide as CoinPaprika's 307 chains and nearly six times Mobula's 81. This is the clearest expression of the breadth-versus-depth trade-off in the data API market. + +CoinGecko's registry breadth reflects a decade of manual chain onboarding and a community-submission model. Reaching 461 chains means accepting chains with thin liquidity, inactive validators, and minimal trading activity. The registry count measures scope, not data quality. A chain with one active token and a single liquidity pool is still counted. + +CoinGecko's registry breadth does not correlate with real-time price freshness — CoinGecko has no entry in the aggregator-head-lag bench. The asset registry and the price feed are different products serving different use cases: token discovery and contract-address lookup versus live market data. A builder who needs both must combine providers. + +The practical decision: if you need to answer "does this contract exist on chain X", CoinGecko's registry is the deepest lookup available. If you need a real-time price for a token on that chain, you need Mobula or Codex. + +## Quote Coverage for New Tokens + + + +The token quote bench measures something different from all other coverage benches: it tests providers on tokens created within the last hour, sourced from live launchpad feeds. This is the hardest case — the token may have no liquidity on major venues, no metadata, and may exist only on a single chain. + +Jupiter's 96.6% is the strongest absolute figure in the entire data API cohort across all nine benchmarks. On Solana, where the majority of its probe tokens live, Jupiter routes nearly every token successfully. Jupiter quotes 96 of 100 freshly launched tokens, a direct consequence of its native integration with Solana's pool infrastructure — it sees new pools seconds after creation. + +KyberSwap at 92.9% covers EVM chains competently. Mobula at 76.4% trails both, meaning roughly one in four new tokens across chains cannot be quoted. For applications that handle established tokens only (top-1,000 by market cap), all three providers will perform near 100%. The quote-coverage bench is specifically relevant for launchpad analytics, meme-token apps, or any product that needs to quote tokens within minutes of their creation. + +## Wallet Indexing: The Speed Cliff + + + +The indexing freshness bench reveals the sharpest divide in the data API market. Three providers cluster under 4 seconds; one sits far outside that range. + +| Provider | p50 | p90 | p99 | Success Rate | +|---|---:|---:|---:|---:| +| Zerion | 1.5 s | 2.0 s | 9.9 s | 100% | +| Mobula | 1.9 s | 7.2 s | 10.5 s | 100% | +| Allium | 3.1 s | 4.4 s | 5.8 s | 100% | +| Moralis | 14.5 s | 21.8 s | 42.4 s | 85.7% | + +Zerion and Mobula are the fastest wallet indexers in the cohort, but they achieve their speed differently. Zerion's distribution is tight: the gap between p50 (1.5 s) and p90 (2.0 s) is 0.5 seconds, suggesting a consistent streaming pipeline with minimal jitter. Mobula's p90 (7.2 s) is 3.8x its p50 (1.9 s), indicating occasional spikes — still fast in absolute terms, but more variable. + +Allium's distribution is the most consistent in the cohort. Its p99 of 5.8 s is lower than Mobula's p90, meaning Allium almost never produces a slow outlier. The trade-off is a higher median (3.1 s) — Allium sacrifices peak speed for consistency, which matters for applications that need predictable SLAs over maximum throughput. + +Moralis sits at 14.5 s with an 85.7% success rate — it indexes one event in seven more than two minutes late or not at all. The 42-second p99 suggests some wallet addresses take significantly longer to index, likely because Moralis uses on-demand indexing triggered by the first query on a new address rather than streaming all activity. The bench probes exclusively fresh addresses (never previously queried), which is precisely the worst case for on-demand indexing. + +The 14.3% miss rate has a direct product consequence: roughly one in seven users who open a wallet app built on Moralis on a fresh address will see an incomplete or empty transaction list for the first 30 seconds. For transaction monitoring or alert applications where a missed event is a real failure, 100% success rate is a hard requirement. Zerion, Mobula, and Allium all meet it. + +## DEX Coverage: Breadth vs. Freshness + + + +GeckoTerminal's 253 chains is a market-leading figure by a wide margin. Codex's 122 chains is the next closest at roughly half. Sim by Dune at 64 covers EVM mainnets only. DexPaprika at 36 is the narrowest in the cohort. + +The juxtaposition with the head-lag bench is the clearest illustration of the breadth-freshness trade-off in the entire dataset. GeckoTerminal leads DEX coverage by 2x and trails on price freshness by 17x. These are not separate failures — they are the same architecture decision viewed from two angles. Indexing 253 chains with a streaming price pipeline is not technically feasible on a data API provider's infrastructure budget in 2026. The choice to cover more chains is the choice to accept a longer synchronization cycle. + +For DEX analytics, backtesting, chain comparisons, or any use case that does not require sub-second prices, GeckoTerminal's breadth is the correct trade-off. For applications that need current prices on a specific chain, Codex or Mobula offer far fresher data on their supported chains, with the DEX chain count as the cost. + +## NFT Metadata: The Alchemy Gap + + + +The NFT metadata bench has the narrowest competitive field in this report: three providers, all benchmarked against a fixed set of 50 Ethereum blue-chip collections. All three return 100% API availability — the ranking is driven entirely by coverage completeness. + +Moralis leads at 97.1%, OpenSea at 93.2%, and Alchemy at 73.7%. The 23-percentage-point gap between Moralis and Alchemy is the largest spread between a cohort leader and a major incumbent in any category in this report. + +Alchemy's gap is specific to the `floor_eth` field. Alchemy's `getContractMetadata` endpoint focuses on on-chain collection metadata — name, image, external URL — rather than marketplace-sourced order book data. Delivering a live floor price requires actively polling or subscribing to marketplace orders, which is not the primary function of Alchemy's contract metadata endpoint. OpenSea, which operates its own marketplace, surfaces floor prices naturally — though the bench notes this costs two API calls per collection versus one for Moralis. + +For builders who need collection-level metadata plus floor prices from a single endpoint, Moralis is the clear choice. For on-chain metadata only (name, image, external URL), Alchemy is competitive despite the lower headline figure — the gap collapses when `floor_eth` is excluded from the score. + +## Wallet Labels: No One Owns the Graph + + + +The wallet labeling bench has the most providers of any category in this report: nine across eleven chains. The leaderboard structure is clear: chain-native specialists occupy the top three positions. + +| Provider | Coverage | Primary Chain | +|---|---:|---| +| Helius | 84.1% | Solana | +| StellarExpert | 80.0% | Stellar | +| XRPScan | 79.8% | XRP | +| Blockscout | 55.9% | EVM (explorer) | +| OLI | 50.4% | EVM (standard) | +| Moralis | 44.6% | Multi-chain | +| Mobula | 43.5% | Multi-chain | +| TonAPI | 35.4% | TON | +| WalletExplorer | 19.9% | Bitcoin / EVM | + +Helius (Solana), StellarExpert (Stellar), and XRPScan (XRP) each maintain manually curated entity graphs for their specific chain. Their coverage is built on years of chain-specific research, community tagging, and validator partnerships — not algorithmic entity resolution. The result is a 40-percentage-point lead over general-purpose multi-chain providers (Moralis at 44.6%, Mobula at 43.5%). + +This is not a quality failure by multi-chain providers. It reflects the fundamental difficulty of maintaining a curated entity graph across many chains simultaneously. Wallet labeling is editorial work at scale — someone must decide that address 0x... is "Binance Hot Wallet 14" — and chain-native teams have the ecosystem context and community relationships to do that work accurately and quickly. + +OLI (Open Labels Initiative), which attempts a decentralized labeling standard on EVM chains, sits at 50.4% — marginally ahead of Blockscout (55.9% for explorers, 50.4% for OLI) but not dramatically better than general-purpose providers. The curation problem is harder than the coordination problem: even with a shared protocol, high-coverage entity resolution requires significant editorial investment. + +TonAPI at 35.4% reflects TON's still-developing ecosystem tooling. WalletExplorer at 19.9% has near-perfect API availability (99.8%) but the narrowest entity graph in the cohort — it has labels, just very few of them. + +## Cross-Provider Scorecard + +Across nine benchmarks, the competitive landscape resolves into four archetypes. + +**Speed specialists** optimize for real-time data at the cost of breadth. Mobula (707 ms head lag, 1.9 s indexing) and Zerion (1.5 s indexing) lead their primary categories and support a narrower set of chains than the broadest players. + +**Coverage maximalists** maximize breadth at the cost of freshness. GeckoTerminal (253 DEX chains, 12.5 s head lag) and CoinGecko (461 asset registry chains, no real-time price bench) define this archetype. Their value is "find any chain, any token" rather than "get the latest price fast." + +**Vertical specialists** dominate a single chain or use case. Jupiter (96.6% Solana quote coverage), Helius (84.1% Solana wallet labels), and Moralis (97.1% NFT metadata) each lead in a category where their infrastructure confers a structural advantage. None of them lead in a second category. + +**Generalists** achieve mid-table finishes across multiple categories. Codex and Mobula both appear in multiple benches with competitive but rarely dominant scores. Codex leads token metadata by 0.6 pp over Mobula and indexes 122 DEX chains; Mobula leads price feeds and ranks second on wallet indexing. Neither is the obvious answer for an application that needs everything — because no single-provider answer exists yet. + +## Decision Framework + + +Price freshness is the primary constraint. Use Mobula (707 ms p50 globally, 99 ms on Solana) or Codex (1,169 ms). Both run near-100% success rates. Check the per-chain breakdown on the [aggregator-head-lag](/benchmarks/aggregator-head-lag) bench before committing — Base is a near coin-flip between them, Solana is not. + + + +Quote coverage on fresh tokens is the constraint. Jupiter is the only choice for Solana launchpad tokens (96.6%). For EVM chains (Base, BNB), KyberSwap (92.9%) leads; Mobula (76.4%) covers the broadest set of chains at the cost of a ~24% miss rate on brand-new tokens. Build a fallback path for missing quotes. + + + +Indexing freshness determines whether a user sees their transaction immediately after confirmation. Zerion (1.5 s) or Mobula (1.9 s) for maximum speed. Allium (3.1 s) for maximum consistency with no success rate degradation. Avoid Moralis if users frequently open the app on cold addresses — the 14.5 s median and 14.3% miss rate will generate visible UX failures. + + + +CoinGecko's 461-chain registry is the deepest single source for contract address lookup. For DEX pool metadata on niche chains, GeckoTerminal covers 253. Both are static or near-static lookups — safe to cache aggressively. Neither is a real-time price source. + + + +Moralis leads (97.1%) and delivers floor prices in a single API call. OpenSea is competitive (93.2%) but costs two calls per collection. Alchemy's 73.7% headline is largely driven by the floor-price gap — if you don't display floor prices, Alchemy is closer to parity on the remaining four fields. + + + +Wallet labeling requires chain-native providers for maximum coverage. For Solana: Helius (84.1%). For XRP: XRPScan (79.8%). For Stellar: StellarExpert (80%). For EVM: Blockscout (55.9%) or OLI (50.4%). No single provider reaches above 85% across all eleven chains simultaneously — plan for missing labels on non-specialist chains as the baseline, not the edge case. + + + +GeckoTerminal's 253-chain index is the only viable answer for breadth. Accept the 12-second price lag as a feature of the product architecture, not a bug. For analytics workloads running on historical or near-real-time data, the lag is irrelevant. For anything requiring current prices, use Mobula or Codex on the subset of chains they support. + + +## Sources + +All data in this report is derived from OpenChainBench's live benchmarks. Figures are p50 over a 24-hour rolling window unless noted. Bench data is live and updates continuously — figures in this report reflect the state as of August 4, 2026. + +- **Price feeds:** [aggregator-head-lag](/benchmarks/aggregator-head-lag) · [api/stat/aggregator-head-lag](/api/stat/aggregator-head-lag) +- **Token metadata:** [metadata-coverage](/benchmarks/metadata-coverage) · [asset-registry-coverage](/benchmarks/asset-registry-coverage) · [token-quote-coverage](/benchmarks/token-quote-coverage) +- **Wallet data:** [indexing-freshness](/benchmarks/indexing-freshness) · [wallet-labels-coverage](/benchmarks/wallet-labels-coverage) +- **DEX:** [dex-network-coverage](/benchmarks/dex-network-coverage) +- **NFT:** [nft-collection-metadata](/benchmarks/nft-collection-metadata) +- **Data API hub:** [/data-api](/data-api) — live cross-bench rankings, updated every 60 seconds +- **Harness source:** [github.com/ChainBench/OpenChainBench/harnesses](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses) +- **License:** All data and figures in this report are published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). You may reproduce them with attribution to OpenChainBench and a link to the canonical URL. +- **Corrections:** File a [GitHub issue](https://github.com/ChainBench/OpenChainBench/issues/new). Material corrections are applied in place with a dated note. diff --git a/src/lib/reports/loader.ts b/src/lib/reports/loader.ts index 0f10f221..61fbaffa 100644 --- a/src/lib/reports/loader.ts +++ b/src/lib/reports/loader.ts @@ -42,6 +42,11 @@ export const REPORT_CATEGORY_META: Record< description: "On-chain prediction markets benchmarked for quote availability, market coverage, and resolution latency.", }, + "data-api": { + label: "Data APIs", + description: + "Crypto data APIs benchmarked across price feeds, token metadata, wallet indexing, DEX coverage, and NFT data.", + }, }; function parseReport(filePath: string): Report { From d6c4c2816d58a07bab5fb4256a73c78ab3369f5f Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 4 Aug 2026 10:50:56 +0200 Subject: [PATCH 3/3] fix(bench-070): drop GoldRush from indexing-freshness (402 on every probe) --- benchmarks/indexing-freshness.yml | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/benchmarks/indexing-freshness.yml b/benchmarks/indexing-freshness.yml index 961254cf..8ee0b5c5 100644 --- a/benchmarks/indexing-freshness.yml +++ b/benchmarks/indexing-freshness.yml @@ -2,9 +2,9 @@ slug: indexing-freshness number: "070" -title: Freshest wallet data API. Zerion, Moralis, Allium, GoldRush, Mobula +title: Freshest wallet data API. Zerion, Moralis, Allium, Mobula seo_title: "Freshest wallet data API 2026" -seo_description: "How fast do wallet APIs index a new transaction? Zerion, Moralis, Allium, GoldRush, Mobula measured live on organic Base transfers, second by second." +seo_description: "How fast do wallet APIs index a new transaction? Zerion, Moralis, Allium, Mobula measured live on organic Base transfers, second by second." subtitle: Seconds between an organic transfer confirming on Base and the moment each wallet data API first returns it, measured continuously on real user transactions. category: Aggregators status: live @@ -60,7 +60,6 @@ findings: - "{{best_name}} currently leads at {{best_p50}} (p50 of found lags, 24h) across organic Base transfers." - "{{name:zerion}} sits at {{p50:zerion}}. Early runs showed a bimodal pattern, some events indexed in about a second and others surfacing several seconds later, consistent with a caching layer in front of the wallet endpoint." - "{{name:moralis}} runs at {{p50:moralis}} with a notably tight distribution across events." - - "{{name:goldrush}} trails at {{p50:goldrush}} on this probe. Its unified multi-chain schema trades freshness for breadth, a real trade-off teams should weigh explicitly." - "Miss rates matter more than medians: an API that fails to show a deposit within two minutes breaks the user flow entirely, so read the reliability column before the latency one." faq: @@ -115,17 +114,6 @@ providers: success: sum(increase(indexing_probe_total{provider="moralis", result="found"}[24h])) / sum(increase(indexing_probe_total{provider="moralis", result=~"found|missed"}[24h])) sample_size: sum(increase(indexing_probe_total{provider="moralis", result=~"found|missed"}[24h])) series: avg_over_time(indexing_freshness_seconds{provider="moralis"}[1h]) - - slug: goldrush - name: GoldRush - tag: Covalent's multi-chain wallet API, unified schema - formula: "Median (p50) over 24h of visibility lag in seconds between an organic Base transfer confirming and GoldRush's transactions endpoint first returning it, from the shared histogram estimator." - queries: - p50: histogram_quantile(0.5, sum by (le) (increase(indexing_freshness_seconds_histogram_bucket{provider="goldrush"}[24h]))) - p90: histogram_quantile(0.9, sum by (le) (increase(indexing_freshness_seconds_histogram_bucket{provider="goldrush"}[24h]))) - p99: histogram_quantile(0.99, sum by (le) (increase(indexing_freshness_seconds_histogram_bucket{provider="goldrush"}[24h]))) - success: sum(increase(indexing_probe_total{provider="goldrush", result="found"}[24h])) / sum(increase(indexing_probe_total{provider="goldrush", result=~"found|missed"}[24h])) - sample_size: sum(increase(indexing_probe_total{provider="goldrush", result=~"found|missed"}[24h])) - series: avg_over_time(indexing_freshness_seconds{provider="goldrush"}[1h]) - slug: allium name: Allium tag: Enterprise realtime wallet APIs, 100+ chains