diff --git a/src/app/data-api/page.tsx b/src/app/data-api/page.tsx
new file mode 100644
index 00000000..22159832
--- /dev/null
+++ b/src/app/data-api/page.tsx
@@ -0,0 +1,306 @@
+import Link from "next/link";
+import { fetchDataApiSnapshot, GROUP_META, fmtDataValue } from "@/lib/data-api-stats";
+import { DataApiHubTabs } from "@/components/data-api-hub-tabs";
+import { pageMetadata } from "@/lib/page-metadata";
+import { safeJsonLd, buildBreadcrumbJsonLd } from "@/lib/jsonld";
+import { SITE } from "@/data/site";
+
+/**
+ * Hub landing page for the data API vertical: price feeds, token metadata,
+ * portfolio/wallet indexing, DEX coverage, and NFT data.
+ *
+ * Blob-only: loads the materialized bench blobs for each of the 9 data-API
+ * benchmarks. Never touches Prometheus at render time. Graceful degradation
+ * if blobs are missing — the page renders the "warming up" state with direct
+ * bench links, never a 404 or throw.
+ */
+
+const DESCRIPTION =
+  "Live benchmark rankings for crypto data APIs: price feed latency, token metadata coverage, wallet indexing freshness, DEX chain coverage, and NFT data quality.";
+
+export const metadata: import("next").Metadata = pageMetadata({
+  path: "/data-api",
+  title: "Best Crypto Data API 2026, ranked by benchmark",
+  description: DESCRIPTION,
+});
+
+export const revalidate = 60;
+
+const BENCH_SLUGS = [
+  "aggregator-head-lag",
+  "metadata-coverage",
+  "asset-registry-coverage",
+  "token-quote-coverage",
+  "indexing-freshness",
+  "portfolio-chain-coverage",
+  "wallet-labels-coverage",
+  "dex-network-coverage",
+  "nft-collection-metadata",
+] as const;
+
+export default async function DataApiHubPage() {
+  const snapshot = await fetchDataApiSnapshot();
+
+  const breadcrumbLd = {
+    "@context": "https://schema.org",
+    ...buildBreadcrumbJsonLd([
+      { name: "Home", item: SITE.url },
+      { name: "Data API benchmarks", item: `${SITE.url}/data-api` },
+    ]),
+  };
+
+  const itemListLd = {
+    "@context": "https://schema.org",
+    "@type": "ItemList",
+    name: "Crypto data API benchmarks by OpenChainBench",
+    description: DESCRIPTION,
+    numberOfItems: BENCH_SLUGS.length,
+    itemListElement: BENCH_SLUGS.map((slug, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      name: slug,
+      url: `${SITE.url}/benchmarks/${slug}`,
+    })),
+  };
+
+  return (
+    <article
+      className="mx-auto max-w-[1400px] px-4 sm:px-6 py-12 sm:py-16"
+      style={{
+        background:
+          "linear-gradient(180deg, rgba(139,92,246,0.06), rgba(139,92,246,0) 320px)",
+      }}
+    >
+      <script
+        type="application/ld+json"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+        dangerouslySetInnerHTML={{ __html: safeJsonLd(breadcrumbLd) }}
+      />
+      <script
+        type="application/ld+json"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+        dangerouslySetInnerHTML={{ __html: safeJsonLd(itemListLd) }}
+      />
+
+      <header className="mb-8">
+        <p className="label-mono text-violet-600 mb-2"
+          style={{ fontFamily: "var(--font-mono, monospace)" }}>
+          Data APIs
+        </p>
+        <h1 className="display text-4xl sm:text-5xl text-ink">
+          Crypto data API benchmarks
+        </h1>
+        <p className="mt-4 max-w-2xl text-base sm:text-lg text-ink-soft leading-snug">
+          Nine independent benchmarks across five categories: price feed head
+          lag, token metadata coverage, wallet indexing freshness, DEX network
+          coverage, and NFT data quality. Every number is measured live from
+          the same harness on the same schedule. No marketing claims, just probe
+          data.
+        </p>
+
+        {/* Bench spec badges */}
+        <div className="mt-4 flex flex-wrap items-center gap-2 text-[12px]">
+          {BENCH_SLUGS.slice(0, 5).map((slug) => (
+            <Link
+              key={slug}
+              href={`/benchmarks/${slug}`}
+              className="inline-flex items-center gap-1.5 rounded-full border border-violet-500/30 bg-violet-500/8 px-3 py-1 hover:bg-violet-500/14 transition-colors"
+            >
+              <span
+                className="label-mono text-ink-faint text-[10px]"
+                style={{ fontFamily: "var(--font-mono, monospace)" }}
+              >
+                Bench
+              </span>
+              <span className="text-ink text-[11px]">{slug}</span>
+            </Link>
+          ))}
+          {BENCH_SLUGS.length > 5 && (
+            <span className="text-[11px] text-ink-faint">
+              +{BENCH_SLUGS.length - 5} more
+            </span>
+          )}
+        </div>
+      </header>
+
+      {snapshot ? (
+        <>
+          {/* KPI strip */}
+          <section className="grid grid-cols-2 sm:grid-cols-4 gap-3 mb-8">
+            <KpiCard
+              label="Providers benchmarked"
+              value={String(snapshot.totals.uniqueProviders)}
+              accent="#8b5cf6"
+            />
+            <KpiCard
+              label="Active benchmarks"
+              value={String(snapshot.totals.benchCount)}
+            />
+            <KpiCard
+              label="Freshest price feed"
+              value={
+                snapshot.totals.headlinePriceFeed
+                  ? `${snapshot.totals.headlinePriceFeed.name} · ${snapshot.totals.headlinePriceFeed.value}`
+                  : "..."
+              }
+              tip="Best provider on aggregator-head-lag (p50 head lag, 24h, all chains & regions)."
+              accent="#f59e0b"
+            />
+            <KpiCard
+              label="Fastest wallet indexing"
+              value={
+                snapshot.totals.headlineIndexing
+                  ? `${snapshot.totals.headlineIndexing.name} · ${snapshot.totals.headlineIndexing.value}`
+                  : "..."
+              }
+              tip="Best provider on indexing-freshness: seconds from Base tx confirm to API visibility (p50, 24h)."
+              accent="#10b981"
+            />
+          </section>
+
+          {/* Group summary pills */}
+          <div className="flex flex-wrap gap-2 mb-8">
+            {snapshot.groups.map(({ group, benches }) => {
+              const meta = GROUP_META[group];
+              const leader = benches[0]?.leader;
+              return (
+                <div
+                  key={group}
+                  className="flex items-center gap-2 rounded-lg border border-ink/10 px-3 py-2 bg-paper-soft/40"
+                >
+                  <span
+                    className="inline-block w-2 h-2 rounded-full flex-shrink-0"
+                    style={{ background: meta.accent }}
+                  />
+                  <span className="text-[12px] font-medium text-ink">{meta.shortLabel}</span>
+                  {leader && (
+                    <span className="text-[11px] text-ink-faint ml-1">
+                      {leader.name}
+                      {" "}
+                      <span
+                        className="label-mono font-semibold"
+                        style={{ color: meta.accent, fontFamily: "var(--font-mono, monospace)" }}
+                      >
+                        {fmtDataValue(leader.p50, benches[0].unit)}
+                      </span>
+                    </span>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+
+          <DataApiHubTabs snapshot={snapshot} />
+
+          <p className="mt-6 text-[11px] text-ink-faint italic">
+            All numbers are p50 values from the trailing 24h window unless noted.
+            Click any bench title for the full leaderboard with p90/p99, per-region
+            tabs, and time-series charts. Refresh interval 60s.
+          </p>
+        </>
+      ) : (
+        <WarmingUp />
+      )}
+
+      <footer className="mt-16 pt-6 border-t border-ink/10 text-[12px] text-ink-soft leading-relaxed">
+        <p className="label-mono text-ink-faint mb-2"
+          style={{ fontFamily: "var(--font-mono, monospace)" }}>
+          Methodology
+        </p>
+        <p className="max-w-3xl">
+          Each benchmark uses an independent probe harness with its own
+          cadence and measurement axis. Price feed head lag captures
+          millisecond-precision timestamps at the probe node and at each
+          provider API, computing the wall-clock difference. Metadata and
+          coverage benches hit provider endpoints with canonical test tokens
+          or addresses, recording which fields are populated. Indexing
+          freshness measures the gap between a Base block confirmation and
+          the moment each wallet API returns the transaction. All harnesses
+          are open source on{" "}
+          <Link
+            href="https://github.com/ChainBench/OpenChainBench"
+            className="underline hover:text-ink"
+            rel="noopener noreferrer"
+            target="_blank"
+          >
+            GitHub
+          </Link>
+          . Data released under{" "}
+          <Link
+            href="https://creativecommons.org/licenses/by/4.0/"
+            className="underline"
+            rel="noopener noreferrer"
+            target="_blank"
+          >
+            CC BY 4.0
+          </Link>
+          .
+        </p>
+      </footer>
+    </article>
+  );
+}
+
+function KpiCard({
+  label,
+  value,
+  accent,
+  tip,
+}: {
+  label: string;
+  value: string;
+  accent?: string;
+  tip?: string;
+}) {
+  return (
+    <div
+      className="card-soft rounded-lg p-3 sm:p-4 border border-ink/15"
+      title={tip}
+    >
+      <p
+        className="label-mono text-[10px] text-ink-faint mb-1 flex items-center gap-1.5"
+        style={{ fontFamily: "var(--font-mono, monospace)" }}
+      >
+        {accent && (
+          <span
+            className="inline-block w-2 h-2 rounded-full flex-shrink-0"
+            style={{ background: accent }}
+          />
+        )}
+        {label}
+      </p>
+      <p className="text-base sm:text-xl font-semibold tabular-nums leading-tight text-ink">
+        {value}
+      </p>
+    </div>
+  );
+}
+
+function WarmingUp() {
+  return (
+    <section className="rounded-xl border border-ink/10 card-soft p-6 sm:p-8">
+      <p
+        className="label-mono text-[10px] text-ink-faint mb-2"
+        style={{ fontFamily: "var(--font-mono, monospace)" }}
+      >
+        Data warming up
+      </p>
+      <p className="text-sm text-ink-soft max-w-2xl leading-relaxed">
+        The cross-bench snapshot has not yet been published. Individual
+        benchmark pages are already live:
+      </p>
+      <ul className="mt-4 flex flex-wrap gap-2 text-[12.5px]">
+        {BENCH_SLUGS.map((slug) => (
+          <li key={slug}>
+            <Link
+              href={`/benchmarks/${slug}`}
+              className="inline-flex rounded-full border border-ink/15 px-3 py-1 text-ink-soft hover:text-ink hover:border-ink/30 transition-colors"
+            >
+              {slug}
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </section>
+  );
+}
diff --git a/src/components/data-api-bench-groups.tsx b/src/components/data-api-bench-groups.tsx
new file mode 100644
index 00000000..e57ae98b
--- /dev/null
+++ b/src/components/data-api-bench-groups.tsx
@@ -0,0 +1,271 @@
+"use client";
+
+import Link from "next/link";
+import { ProviderLogo } from "@/components/provider-logo";
+import {
+  GROUP_META,
+  fmtDataValue,
+  type DataApiGroupRow,
+  type DataApiBenchRow,
+  type RegionLeader,
+  type ChainLeader,
+} from "@/lib/data-api-stats";
+
+export function DataApiBenchGroups({ groups }: { groups: DataApiGroupRow[] }) {
+  return (
+    <div className="space-y-10">
+      {groups.map(({ group, benches }) => {
+        const meta = GROUP_META[group];
+        return (
+          <section key={group}>
+            <div className="flex items-center gap-2.5 mb-4">
+              <span
+                className="inline-block w-2.5 h-2.5 rounded-full flex-shrink-0"
+                style={{ background: meta.accent }}
+              />
+              <h2 className="text-[15px] font-semibold text-ink">{meta.label}</h2>
+              <span className="text-[11px] text-ink-faint ml-1">{meta.description}</span>
+            </div>
+
+            <div className="rounded-xl border border-ink/10 card-soft overflow-hidden">
+              <div className="overflow-x-auto">
+                <table className="w-full text-[13px]">
+                  <thead>
+                    <tr className="border-b border-ink/8 bg-paper-soft/50">
+                      <Th className="pl-5 pr-3 py-3 text-left w-[200px]">Benchmark</Th>
+                      <Th className="px-3 py-3 text-right w-[60px]">Providers</Th>
+                      <Th className="px-3 py-3 text-left">Leader</Th>
+                      <Th className="px-3 py-3 text-left hidden sm:table-cell">Runners-up</Th>
+                      <Th className="pl-3 pr-5 py-3 text-left hidden lg:table-cell">By region / chain</Th>
+                    </tr>
+                  </thead>
+                  <tbody className="divide-y divide-ink/5">
+                    {benches.map((bench) => (
+                      <BenchRow
+                        key={bench.slug}
+                        bench={bench}
+                        accent={meta.accent}
+                      />
+                    ))}
+                  </tbody>
+                </table>
+              </div>
+            </div>
+          </section>
+        );
+      })}
+    </div>
+  );
+}
+
+function BenchRow({
+  bench,
+  accent,
+}: {
+  bench: DataApiBenchRow;
+  accent: string;
+}) {
+  const hasRegions = bench.regionLeaders.length > 0;
+  const hasChains = bench.chainLeaders.length > 0;
+  const showRegionChain = hasRegions || hasChains;
+
+  return (
+    <tr className="group hover:bg-paper-soft/40 transition-colors">
+      {/* Bench title + number */}
+      <td className="pl-5 pr-3 py-3.5 align-top">
+        <div className="flex flex-col gap-0.5">
+          <Link
+            href={`/benchmarks/${bench.slug}`}
+            className="font-medium text-ink hover:text-violet-600 transition-colors leading-snug"
+          >
+            {bench.shortTitle}
+          </Link>
+          <div className="flex items-center gap-1.5">
+            <span
+              className="label-mono text-[10px] text-ink-faint"
+              style={{ fontFamily: "var(--font-mono, monospace)" }}
+            >
+              #{bench.number}
+            </span>
+            <span className="text-[10px] text-ink-faint">{bench.metric}</span>
+          </div>
+        </div>
+      </td>
+
+      {/* Provider count */}
+      <td className="px-3 py-3.5 align-top text-right">
+        <span
+          className="label-mono text-ink-faint text-[12px]"
+          style={{ fontFamily: "var(--font-mono, monospace)" }}
+        >
+          {bench.providerCount > 0 ? bench.providerCount : "..."}
+        </span>
+      </td>
+
+      {/* Leader */}
+      <td className="px-3 py-3.5 align-top min-w-[160px]">
+        {bench.leader ? (
+          <div className="flex items-center gap-2">
+            <ProviderLogo
+              slug={bench.leader.slug}
+              name={bench.leader.name}
+              size={18}
+            />
+            <div className="flex flex-col">
+              <span className="font-medium text-ink leading-tight">
+                {bench.leader.name}
+              </span>
+              <span
+                className="label-mono text-[11px] font-semibold"
+                style={{ color: accent, fontFamily: "var(--font-mono, monospace)" }}
+              >
+                {fmtDataValue(bench.leader.p50, bench.unit)}
+              </span>
+            </div>
+          </div>
+        ) : (
+          <span className="text-ink-faint">warming up</span>
+        )}
+      </td>
+
+      {/* Runners-up */}
+      <td className="px-3 py-3.5 align-top hidden sm:table-cell min-w-[180px]">
+        <div className="flex flex-col gap-1">
+          {bench.runners.length > 0 ? (
+            bench.runners.map((r, i) => (
+              <div key={r.slug} className="flex items-center gap-1.5">
+                <span className="text-[10px] text-ink-faint w-3 text-right flex-shrink-0">
+                  {i + 2}
+                </span>
+                <ProviderLogo slug={r.slug} name={r.name} size={14} />
+                <span className="text-ink-soft text-[12px] leading-tight truncate">
+                  {r.name}
+                </span>
+                <span
+                  className="label-mono text-[10.5px] text-ink-faint ml-auto pl-1"
+                  style={{ fontFamily: "var(--font-mono, monospace)" }}
+                >
+                  {fmtDataValue(r.p50, bench.unit)}
+                </span>
+              </div>
+            ))
+          ) : (
+            <span className="text-ink-faint text-[12px]">...</span>
+          )}
+        </div>
+      </td>
+
+      {/* Region / chain breakdown */}
+      <td className="pl-3 pr-5 py-3.5 align-top hidden lg:table-cell">
+        {showRegionChain ? (
+          <div className="flex flex-col gap-2">
+            {hasRegions && (
+              <RegionStrip leaders={bench.regionLeaders} unit={bench.unit} />
+            )}
+            {hasChains && !hasRegions && (
+              <ChainStrip leaders={bench.chainLeaders} unit={bench.unit} />
+            )}
+          </div>
+        ) : (
+          <span className="text-ink-faint text-[11px]">global</span>
+        )}
+      </td>
+    </tr>
+  );
+}
+
+function RegionStrip({
+  leaders,
+  unit,
+}: {
+  leaders: RegionLeader[];
+  unit: DataApiBenchRow["unit"];
+}) {
+  const ORDER = ["us-east", "eu-west", "sgp"];
+  const sorted = [...leaders].sort(
+    (a, b) => ORDER.indexOf(a.region) - ORDER.indexOf(b.region),
+  );
+
+  return (
+    <div className="flex flex-wrap gap-1.5">
+      {sorted.map((l) => (
+        <div
+          key={l.region}
+          className="flex items-center gap-1 rounded-md border border-ink/8 bg-paper-soft/60 px-2 py-1"
+          title={`${l.label}: ${l.providerName} — ${fmtDataValue(l.p50, unit)}`}
+        >
+          <span
+            className="label-mono text-[9px] text-ink-faint uppercase tracking-wide"
+            style={{ fontFamily: "var(--font-mono, monospace)" }}
+          >
+            {l.region === "us-east" ? "US" : l.region === "eu-west" ? "EU" : "SGP"}
+          </span>
+          <ProviderLogo slug={l.providerSlug} name={l.providerName} size={12} />
+          <span className="text-[10.5px] text-ink-soft font-medium">
+            {l.providerName.split(" ")[0]}
+          </span>
+          <span
+            className="label-mono text-[10px] text-ink-faint"
+            style={{ fontFamily: "var(--font-mono, monospace)" }}
+          >
+            {fmtDataValue(l.p50, unit)}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function ChainStrip({
+  leaders,
+  unit,
+}: {
+  leaders: ChainLeader[];
+  unit: DataApiBenchRow["unit"];
+}) {
+  return (
+    <div className="flex flex-wrap gap-1.5">
+      {leaders.map((l) => (
+        <div
+          key={l.chain}
+          className="flex items-center gap-1 rounded-md border border-ink/8 bg-paper-soft/60 px-2 py-1"
+          title={`${l.label}: ${l.providerName} — ${fmtDataValue(l.p50, unit)}`}
+        >
+          <span
+            className="label-mono text-[9px] text-ink-faint uppercase tracking-wide"
+            style={{ fontFamily: "var(--font-mono, monospace)" }}
+          >
+            {l.label}
+          </span>
+          <ProviderLogo slug={l.providerSlug} name={l.providerName} size={12} />
+          <span className="text-[10.5px] text-ink-soft font-medium">
+            {l.providerName.split(" ")[0]}
+          </span>
+          <span
+            className="label-mono text-[10px] text-ink-faint"
+            style={{ fontFamily: "var(--font-mono, monospace)" }}
+          >
+            {fmtDataValue(l.p50, unit)}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function Th({
+  children,
+  className = "",
+}: {
+  children?: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <th
+      className={`label-mono text-[10px] text-ink-faint font-medium ${className}`}
+      style={{ fontFamily: "var(--font-mono, monospace)" }}
+    >
+      {children}
+    </th>
+  );
+}
diff --git a/src/components/data-api-hub-tabs.tsx b/src/components/data-api-hub-tabs.tsx
new file mode 100644
index 00000000..5f811a86
--- /dev/null
+++ b/src/components/data-api-hub-tabs.tsx
@@ -0,0 +1,79 @@
+"use client";
+
+import { useState } from "react";
+import { DataApiBenchGroups } from "@/components/data-api-bench-groups";
+import { DataApiProvidersPivot } from "@/components/data-api-providers-pivot";
+import type { DataApiSnapshot } from "@/lib/data-api-stats";
+
+type Tab = "benchmarks" | "providers";
+
+export function DataApiHubTabs({ snapshot }: { snapshot: DataApiSnapshot }) {
+  const [tab, setTab] = useState<Tab>("benchmarks");
+
+  return (
+    <>
+      <div
+        className="inline-flex rounded-lg border border-ink/15 p-1 bg-paper-soft/40 mb-6"
+        role="tablist"
+        aria-label="Data API benchmarks view"
+      >
+        <TabButton
+          active={tab === "benchmarks"}
+          onClick={() => setTab("benchmarks")}
+          count={snapshot.totals.benchCount}
+        >
+          By benchmark
+        </TabButton>
+        <TabButton
+          active={tab === "providers"}
+          onClick={() => setTab("providers")}
+          count={snapshot.totals.uniqueProviders}
+        >
+          By provider
+        </TabButton>
+      </div>
+
+      {tab === "benchmarks" && (
+        <DataApiBenchGroups groups={snapshot.groups} />
+      )}
+      {tab === "providers" && (
+        <DataApiProvidersPivot
+          rows={snapshot.providers}
+          groupCount={snapshot.totals.groupCount}
+        />
+      )}
+    </>
+  );
+}
+
+function TabButton({
+  children,
+  active,
+  count,
+  onClick,
+}: {
+  children: React.ReactNode;
+  active: boolean;
+  count: number;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      role="tab"
+      aria-selected={active}
+      onClick={onClick}
+      className={`px-4 py-1.5 rounded-md text-[13px] font-medium transition-colors flex items-center gap-2 ${
+        active ? "bg-paper text-ink shadow-sm" : "text-ink-soft hover:text-ink"
+      }`}
+    >
+      {children}
+      <span
+        className="text-[10.5px] text-ink-faint"
+        style={{ fontFamily: "var(--font-mono, monospace)" }}
+      >
+        {count}
+      </span>
+    </button>
+  );
+}
diff --git a/src/components/data-api-providers-pivot.tsx b/src/components/data-api-providers-pivot.tsx
new file mode 100644
index 00000000..37e391ea
--- /dev/null
+++ b/src/components/data-api-providers-pivot.tsx
@@ -0,0 +1,318 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import Link from "next/link";
+import { ProviderLogo } from "@/components/provider-logo";
+import {
+  GROUP_ORDER,
+  GROUP_META,
+  fmtDataValue,
+  type DataApiProviderPivotRow,
+  type DataApiGroup,
+} from "@/lib/data-api-stats";
+
+type SortKey = "groupCount" | DataApiGroup;
+
+export function DataApiProvidersPivot({
+  rows,
+  groupCount,
+}: {
+  rows: DataApiProviderPivotRow[];
+  groupCount: number;
+}) {
+  const [sortKey, setSortKey] = useState<SortKey>("groupCount");
+  const [sortDir, setSortDir] = useState<"asc" | "desc">("desc");
+  const [q, setQ] = useState("");
+
+  const filtered = useMemo(() => {
+    const needle = q.trim().toLowerCase();
+    const base = needle
+      ? rows.filter(
+          (r) =>
+            r.name.toLowerCase().includes(needle) ||
+            r.slug.toLowerCase().includes(needle),
+        )
+      : rows;
+
+    return [...base].sort((a, b) => {
+      const factor = sortDir === "desc" ? -1 : 1;
+
+      if (sortKey === "groupCount") {
+        if (b.groupCount !== a.groupCount)
+          return factor * (b.groupCount - a.groupCount);
+        // tie-break: better avg rank
+        const avgA = a.cells.reduce((s, c) => s + c.rank, 0) / (a.cells.length || 1);
+        const avgB = b.cells.reduce((s, c) => s + c.rank, 0) / (b.cells.length || 1);
+        return avgA - avgB;
+      }
+
+      // Sort by a specific group's best rank
+      const cellA = a.groups[sortKey];
+      const cellB = b.groups[sortKey];
+      if (!cellA && !cellB) return 0;
+      if (!cellA) return 1;
+      if (!cellB) return -1;
+      // rank: lower = better always
+      return factor * (cellA.bestRank - cellB.bestRank);
+    });
+  }, [rows, sortKey, sortDir, q]);
+
+  const setSort = (k: SortKey) => {
+    if (k === sortKey) setSortDir((d) => (d === "desc" ? "asc" : "desc"));
+    else {
+      setSortKey(k);
+      setSortDir("desc");
+    }
+  };
+
+  const visibleGroups = GROUP_ORDER.filter(
+    (g) => rows.some((r) => r.groups[g]),
+  );
+
+  return (
+    <div className="rounded-xl border border-ink/10 card-soft overflow-hidden">
+      <div className="px-4 py-3 border-b border-ink/8 flex items-center justify-between gap-3 flex-wrap">
+        <p
+          className="text-[11px] text-ink-faint"
+          style={{ fontFamily: "var(--font-mono, monospace)" }}
+        >
+          {filtered.length} of {rows.length} providers across {groupCount} benchmark groups
+        </p>
+        <input
+          type="search"
+          aria-label="Search provider..."
+          value={q}
+          onChange={(e) => setQ(e.target.value)}
+          placeholder="Search provider..."
+          className="text-[12.5px] px-3 py-1.5 rounded-md border border-ink/15 bg-paper focus:outline-none focus:ring-2 focus:ring-violet-500/30 min-w-[180px]"
+        />
+      </div>
+
+      <div className="overflow-x-auto">
+        <table className="w-full text-[12.5px]">
+          <thead>
+            <tr className="bg-paper-soft/60 text-left">
+              <Th className="pl-4 pr-3 py-2.5 w-6">#</Th>
+              <Th className="px-3 py-2.5 min-w-[150px]">Provider</Th>
+              <ThSort
+                active={sortKey === "groupCount"}
+                dir={sortDir}
+                onClick={() => setSort("groupCount")}
+              >
+                Coverage
+              </ThSort>
+              {visibleGroups.map((g) => (
+                <ThSort
+                  key={g}
+                  active={sortKey === g}
+                  dir={sortDir}
+                  onClick={() => setSort(g)}
+                  accent={GROUP_META[g].accent}
+                >
+                  {GROUP_META[g].shortLabel}
+                </ThSort>
+              ))}
+            </tr>
+          </thead>
+          <tbody className="divide-y divide-ink/5">
+            {filtered.map((row, idx) => (
+              <ProviderRow
+                key={row.slug}
+                row={row}
+                rank={idx + 1}
+                groups={visibleGroups}
+              />
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      {filtered.length === 0 && (
+        <div className="px-4 py-8 text-center text-[13px] text-ink-faint">
+          No providers match &quot;{q}&quot;
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ProviderRow({
+  row,
+  rank,
+  groups,
+}: {
+  row: DataApiProviderPivotRow;
+  rank: number;
+  groups: DataApiGroup[];
+}) {
+  return (
+    <tr className="group hover:bg-paper-soft/30 transition-colors">
+      <td className="pl-4 pr-3 py-3 align-middle">
+        <span
+          className="label-mono text-[10.5px] text-ink-faint"
+          style={{ fontFamily: "var(--font-mono, monospace)" }}
+        >
+          {rank}
+        </span>
+      </td>
+      <td className="px-3 py-3 align-middle">
+        <Link
+          href={`/products/${row.slug}`}
+          className="flex items-center gap-2 hover:text-violet-600 transition-colors"
+        >
+          <ProviderLogo slug={row.slug} name={row.name} size={20} />
+          <span className="font-medium text-ink leading-tight">{row.name}</span>
+        </Link>
+      </td>
+
+      {/* Coverage column */}
+      <td className="px-3 py-3 align-middle">
+        <div className="flex items-center gap-1.5">
+          <span className="font-semibold text-ink">{row.groupCount}</span>
+          <span className="text-ink-faint text-[11px]">/ {groups.length}</span>
+          <div className="flex gap-0.5 ml-1">
+            {groups.map((g) => (
+              <span
+                key={g}
+                className="inline-block w-2 h-2 rounded-full"
+                style={{
+                  background: row.groups[g]
+                    ? GROUP_META[g].accent
+                    : "var(--color-ink-faint, #94a3b8)",
+                  opacity: row.groups[g] ? 1 : 0.2,
+                }}
+                title={
+                  row.groups[g]
+                    ? `${GROUP_META[g].label}: rank #${row.groups[g]!.bestRank}`
+                    : `Not in ${GROUP_META[g].label}`
+                }
+              />
+            ))}
+          </div>
+        </div>
+      </td>
+
+      {/* One cell per group */}
+      {groups.map((g) => (
+        <td key={g} className="px-3 py-3 align-middle">
+          <GroupCell cell={row.groups[g]} group={g} />
+        </td>
+      ))}
+    </tr>
+  );
+}
+
+function GroupCell({
+  cell,
+  group,
+}: {
+  cell: DataApiProviderPivotRow["groups"][DataApiGroup];
+  group: DataApiGroup;
+}) {
+  if (!cell) {
+    return <span className="text-ink-faint/40 text-[11px]">—</span>;
+  }
+
+  const { bestRank, bestCell } = cell;
+  const accent = GROUP_META[group].accent;
+
+  // Color intensity by rank
+  const bg =
+    bestRank === 1
+      ? `${accent}22`
+      : bestRank <= 3
+        ? `${accent}11`
+        : "transparent";
+
+  const textColor =
+    bestRank === 1
+      ? accent
+      : bestRank <= 3
+        ? accent
+        : "var(--color-ink-soft)";
+
+  return (
+    <div
+      className="inline-flex flex-col items-start gap-0.5 rounded-md px-2 py-1.5"
+      style={{ background: bg }}
+      title={`${bestCell.benchShortTitle}: #${bestRank} — ${fmtDataValue(bestCell.p50, bestCell.unit)}`}
+    >
+      <div className="flex items-center gap-1.5">
+        <RankBadge rank={bestRank} accent={accent} />
+        <span
+          className="label-mono text-[11px] font-semibold"
+          style={{ color: textColor, fontFamily: "var(--font-mono, monospace)" }}
+        >
+          {fmtDataValue(bestCell.p50, bestCell.unit)}
+        </span>
+      </div>
+      <span className="text-[9px] text-ink-faint leading-tight">
+        {bestCell.benchShortTitle.replace("coverage", "cov.").replace("freshness", "fresh.")}
+      </span>
+    </div>
+  );
+}
+
+function RankBadge({ rank, accent }: { rank: number; accent: string }) {
+  const bg = rank === 1 ? accent : "transparent";
+  const border = rank <= 3 ? `1px solid ${accent}66` : "1px solid transparent";
+  const color =
+    rank === 1 ? "#fff" : rank <= 3 ? accent : "var(--color-ink-faint)";
+
+  return (
+    <span
+      className="inline-flex items-center justify-center rounded w-4 h-4 text-[9px] font-bold flex-shrink-0"
+      style={{ background: bg, border, color }}
+    >
+      {rank}
+    </span>
+  );
+}
+
+function Th({
+  children,
+  className = "",
+}: {
+  children?: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <th
+      className={`label-mono text-[10px] text-ink-faint font-medium py-2.5 px-3 ${className}`}
+      style={{ fontFamily: "var(--font-mono, monospace)" }}
+    >
+      {children}
+    </th>
+  );
+}
+
+function ThSort({
+  children,
+  active,
+  dir,
+  onClick,
+  accent,
+}: {
+  children: React.ReactNode;
+  active: boolean;
+  dir: "asc" | "desc";
+  onClick: () => void;
+  accent?: string;
+}) {
+  return (
+    <th
+      className="py-2.5 px-3 text-left"
+      style={{ fontFamily: "var(--font-mono, monospace)" }}
+    >
+      <button
+        type="button"
+        onClick={onClick}
+        className="label-mono text-[10px] font-medium flex items-center gap-1 hover:text-ink transition-colors"
+        style={{ color: active ? (accent ?? "var(--color-ink)") : undefined }}
+      >
+        {children}
+        <span className="text-[8px]">{active ? (dir === "desc" ? "▼" : "▲") : "⇅"}</span>
+      </button>
+    </th>
+  );
+}
diff --git a/src/components/site-header.tsx b/src/components/site-header.tsx
index aef5dbd8..032f8ac5 100644
--- a/src/components/site-header.tsx
+++ b/src/components/site-header.tsx
@@ -36,6 +36,11 @@ const NAV: NavItem[] = [
     label: "Benchmarks",
     match: (p) => p === "/benchmarks" || p.startsWith("/benchmarks/"),
   },
+  {
+    href: "/data-api",
+    label: "Data APIs",
+    match: (p) => p === "/data-api" || p.startsWith("/data-api/"),
+  },
   {
     href: "/products",
     label: "Products",
diff --git a/src/lib/data-api-stats.ts b/src/lib/data-api-stats.ts
new file mode 100644
index 00000000..f8a0a084
--- /dev/null
+++ b/src/lib/data-api-stats.ts
@@ -0,0 +1,417 @@
+/**
+ * Server-side helper for the /data-api hub page. Loads bench blobs for
+ * every "data API" benchmark (price feeds, token metadata, portfolio/wallet,
+ * DEX coverage, NFT data) and assembles two views:
+ *
+ *   1. By Benchmark — groups benches by use-case, each bench has its leader,
+ *      runners-up, per-region leaders (when the bench has region data), and
+ *      per-chain leaders (when the bench has bestPerChain populated).
+ *
+ *   2. By Provider — cross-bench pivot: one row per unique provider, one cell
+ *      per group, showing the provider's best rank + value in that group.
+ *
+ * Blob-only: reads from the CDN bench blobs published by the materialize
+ * worker. Never touches Prometheus at render time. Graceful degradation:
+ * missing/empty blobs render as null cells (never a throw).
+ */
+
+import { unstable_cache } from "next/cache";
+import { loadBenchFromBlob } from "@/lib/bench-blob";
+import type { Benchmark, ProviderResult } from "@/types/benchmark";
+
+export type DataApiGroup =
+  | "price-feeds"
+  | "token-metadata"
+  | "portfolio-wallet"
+  | "dex-coverage"
+  | "nft-data";
+
+export const GROUP_ORDER: readonly DataApiGroup[] = [
+  "price-feeds",
+  "token-metadata",
+  "portfolio-wallet",
+  "dex-coverage",
+  "nft-data",
+];
+
+export const GROUP_META: Record<
+  DataApiGroup,
+  { label: string; shortLabel: string; accent: string; description: string }
+> = {
+  "price-feeds": {
+    label: "Price & Market Data",
+    shortLabel: "Price Feeds",
+    accent: "#f59e0b",
+    description: "Real-time price feed latency from on-chain event to API emission.",
+  },
+  "token-metadata": {
+    label: "Token Metadata",
+    shortLabel: "Token Data",
+    accent: "#8b5cf6",
+    description: "Metadata coverage, asset registry depth, and quote routing capacity.",
+  },
+  "portfolio-wallet": {
+    label: "Portfolio & Wallet",
+    shortLabel: "Portfolio",
+    accent: "#10b981",
+    description: "Wallet indexing freshness, portfolio chain coverage, and label accuracy.",
+  },
+  "dex-coverage": {
+    label: "DEX Coverage",
+    shortLabel: "DEX",
+    accent: "#0ea5e9",
+    description: "Number of blockchains where each DEX indexer tracks pools and swap volumes.",
+  },
+  "nft-data": {
+    label: "NFT Data",
+    shortLabel: "NFT",
+    accent: "#f43f5e",
+    description: "Collection metadata field coverage across blue-chip NFT collections.",
+  },
+};
+
+/** Each bench's group. Adding a bench to the hub = one line here. */
+const BENCH_GROUP: Record<string, DataApiGroup> = {
+  "aggregator-head-lag": "price-feeds",
+  "metadata-coverage": "token-metadata",
+  "asset-registry-coverage": "token-metadata",
+  "token-quote-coverage": "token-metadata",
+  "indexing-freshness": "portfolio-wallet",
+  "portfolio-chain-coverage": "portfolio-wallet",
+  "wallet-labels-coverage": "portfolio-wallet",
+  "dex-network-coverage": "dex-coverage",
+  "nft-collection-metadata": "nft-data",
+};
+
+const BENCH_SLUGS = Object.keys(BENCH_GROUP);
+
+/** Short display titles for table rows (trimmed from the full spec title). */
+const BENCH_SHORT_TITLE: Record<string, string> = {
+  "aggregator-head-lag": "Price feed head lag",
+  "metadata-coverage": "Token metadata coverage",
+  "asset-registry-coverage": "Asset registry chains",
+  "token-quote-coverage": "Token quote coverage",
+  "indexing-freshness": "Wallet indexing freshness",
+  "portfolio-chain-coverage": "Portfolio chain coverage",
+  "wallet-labels-coverage": "Wallet label coverage",
+  "dex-network-coverage": "DEX network coverage",
+  "nft-collection-metadata": "NFT metadata coverage",
+};
+
+const CHAIN_LABELS: Record<string, string> = {
+  base: "Base",
+  bnb: "BNB",
+  solana: "SOL",
+  robinhood: "RH",
+  ethereum: "ETH",
+};
+
+export type RegionLeader = {
+  region: string;
+  label: string;
+  providerSlug: string;
+  providerName: string;
+  p50: number;
+};
+
+export type ChainLeader = {
+  chain: string;
+  label: string;
+  providerSlug: string;
+  providerName: string;
+  p50: number;
+};
+
+export type DataApiBenchRow = {
+  slug: string;
+  number: string;
+  title: string;
+  shortTitle: string;
+  metric: string;
+  unit: Benchmark["unit"];
+  higherIsBetter: boolean;
+  leader: { slug: string; name: string; p50: number } | null;
+  runners: { slug: string; name: string; p50: number }[];
+  providerCount: number;
+  regionLeaders: RegionLeader[];
+  chainLeaders: ChainLeader[];
+  updatedAt: string | null;
+};
+
+export type DataApiGroupRow = {
+  group: DataApiGroup;
+  benches: DataApiBenchRow[];
+};
+
+export type DataApiProviderCell = {
+  benchSlug: string;
+  benchShortTitle: string;
+  group: DataApiGroup;
+  rank: number;
+  p50: number;
+  unit: Benchmark["unit"];
+  higherIsBetter: boolean;
+};
+
+export type DataApiProviderPivotRow = {
+  slug: string;
+  name: string;
+  cells: DataApiProviderCell[];
+  groups: Partial<
+    Record<DataApiGroup, { bestRank: number; bestCell: DataApiProviderCell }>
+  >;
+  groupCount: number;
+};
+
+export type DataApiSnapshot = {
+  groups: DataApiGroupRow[];
+  providers: DataApiProviderPivotRow[];
+  totals: {
+    uniqueProviders: number;
+    benchCount: number;
+    groupCount: number;
+    headlinePriceFeed: { name: string; value: string } | null;
+    headlineIndexing: { name: string; value: string } | null;
+  };
+  generatedAt: string;
+};
+
+function liveResults(bench: Benchmark): ProviderResult[] {
+  return bench.results.filter(
+    (r) =>
+      r.availability !== "unavailable" &&
+      !r.unresponsive &&
+      r.ms.p50 > 0 &&
+      r.dataConfidence !== "insufficient",
+  );
+}
+
+function sortedResults(
+  results: ProviderResult[],
+  higherIsBetter: boolean,
+): ProviderResult[] {
+  return [...results].sort((a, b) =>
+    higherIsBetter ? b.ms.p50 - a.ms.p50 : a.ms.p50 - b.ms.p50,
+  );
+}
+
+function computeRegionLeaders(bench: Benchmark): RegionLeader[] {
+  const live = liveResults(bench);
+  const { regions } = bench.extras;
+  if (!regions || Object.keys(regions).length === 0) return [];
+
+  const map = new Map<string, RegionLeader>();
+
+  for (const provider of live) {
+    const pts = regions[provider.slug] ?? [];
+    for (const pt of pts) {
+      if (pt.region === "global") continue;
+      const normalized =
+        pt.region === "ap-southeast" ? "sgp" : pt.region;
+      const label =
+        normalized === "sgp"
+          ? "Singapore"
+          : normalized === "us-east"
+            ? "US East"
+            : "EU West";
+
+      const current = map.get(normalized);
+      const isBetter = bench.higherIsBetter
+        ? pt.p50 > (current?.p50 ?? -Infinity)
+        : pt.p50 < (current?.p50 ?? Infinity);
+
+      if (isBetter || !current) {
+        map.set(normalized, {
+          region: normalized,
+          label,
+          providerSlug: provider.slug,
+          providerName: provider.name,
+          p50: pt.p50,
+        });
+      }
+    }
+  }
+
+  return (["us-east", "eu-west", "sgp"] as const)
+    .filter((r) => map.has(r))
+    .map((r) => map.get(r)!);
+}
+
+function computeChainLeaders(bench: Benchmark): ChainLeader[] {
+  if (!bench.bestPerChain) return [];
+  return Object.entries(bench.bestPerChain)
+    .filter(([, r]) => r.availability !== "unavailable" && !r.unresponsive && r.ms.p50 > 0)
+    .map(([chain, r]) => ({
+      chain,
+      label: CHAIN_LABELS[chain] ?? chain,
+      providerSlug: r.slug,
+      providerName: r.name,
+      p50: r.ms.p50,
+    }))
+    .sort((a, b) => a.label.localeCompare(b.label));
+}
+
+function toBenchRow(slug: string, bench: Benchmark): DataApiBenchRow {
+  const live = sortedResults(liveResults(bench), bench.higherIsBetter);
+  return {
+    slug,
+    number: bench.number,
+    title: bench.title,
+    shortTitle: BENCH_SHORT_TITLE[slug] ?? bench.title,
+    metric: bench.metric,
+    unit: bench.unit,
+    higherIsBetter: bench.higherIsBetter,
+    leader: live[0]
+      ? { slug: live[0].slug, name: live[0].name, p50: live[0].ms.p50 }
+      : null,
+    runners: live.slice(1, 4).map((r) => ({
+      slug: r.slug,
+      name: r.name,
+      p50: r.ms.p50,
+    })),
+    providerCount: live.length,
+    regionLeaders: computeRegionLeaders(bench),
+    chainLeaders: computeChainLeaders(bench),
+    updatedAt: bench.lastRunAt ?? null,
+  };
+}
+
+export function fmtDataValue(v: number, unit: Benchmark["unit"]): string {
+  if (!Number.isFinite(v)) return "...";
+  switch (unit) {
+    case "pct":
+      return `${v.toFixed(1)}%`;
+    case "count":
+      return String(Math.round(v));
+    case "s":
+    case "sec":
+      return v < 1
+        ? `${(v * 1000).toFixed(0)} ms`
+        : `${v.toFixed(2)} s`;
+    case "ms":
+      return `${Math.round(v)} ms`;
+    case "bps":
+    case "bp":
+      return `${v.toFixed(0)} bps`;
+    default:
+      return String(Math.round(v));
+  }
+}
+
+async function buildSnapshot(): Promise<DataApiSnapshot | null> {
+  const settled = await Promise.allSettled(
+    BENCH_SLUGS.map((s) => loadBenchFromBlob(s)),
+  );
+
+  const loaded: [string, Benchmark][] = BENCH_SLUGS.reduce<
+    [string, Benchmark][]
+  >((acc, slug, i) => {
+    const r = settled[i];
+    if (r.status === "fulfilled" && r.value) acc.push([slug, r.value]);
+    return acc;
+  }, []);
+
+  if (loaded.length === 0) return null;
+
+  // Build group rows
+  const groupBenches: Record<DataApiGroup, DataApiBenchRow[]> = {
+    "price-feeds": [],
+    "token-metadata": [],
+    "portfolio-wallet": [],
+    "dex-coverage": [],
+    "nft-data": [],
+  };
+
+  for (const [slug, bench] of loaded) {
+    const group = BENCH_GROUP[slug];
+    if (!group) continue;
+    groupBenches[group].push(toBenchRow(slug, bench));
+  }
+
+  // Build provider pivot
+  type PEntry = { name: string; cells: DataApiProviderCell[] };
+  const providerMap = new Map<string, PEntry>();
+
+  for (const [slug, bench] of loaded) {
+    const group = BENCH_GROUP[slug];
+    if (!group) continue;
+    const live = sortedResults(liveResults(bench), bench.higherIsBetter);
+    for (const [idx, r] of live.entries()) {
+      if (!providerMap.has(r.slug)) {
+        providerMap.set(r.slug, { name: r.name, cells: [] });
+      }
+      providerMap.get(r.slug)!.cells.push({
+        benchSlug: slug,
+        benchShortTitle: BENCH_SHORT_TITLE[slug] ?? slug,
+        group,
+        rank: idx + 1,
+        p50: r.ms.p50,
+        unit: bench.unit,
+        higherIsBetter: bench.higherIsBetter,
+      });
+    }
+  }
+
+  const providerRows: DataApiProviderPivotRow[] = [];
+  for (const [slug, { name, cells }] of providerMap.entries()) {
+    const groups: DataApiProviderPivotRow["groups"] = {};
+    for (const cell of cells) {
+      const cur = groups[cell.group];
+      if (!cur || cell.rank < cur.bestRank) {
+        groups[cell.group] = { bestRank: cell.rank, bestCell: cell };
+      }
+    }
+    providerRows.push({
+      slug,
+      name,
+      cells,
+      groups,
+      groupCount: Object.keys(groups).length,
+    });
+  }
+
+  providerRows.sort((a, b) => {
+    if (b.groupCount !== a.groupCount) return b.groupCount - a.groupCount;
+    const avgA = a.cells.reduce((s, c) => s + c.rank, 0) / (a.cells.length || 1);
+    const avgB = b.cells.reduce((s, c) => s + c.rank, 0) / (b.cells.length || 1);
+    return avgA - avgB;
+  });
+
+  // Headline stats for KPI strip
+  const headLagEntry = loaded.find(([s]) => s === "aggregator-head-lag");
+  const indexingEntry = loaded.find(([s]) => s === "indexing-freshness");
+
+  function headlineStat(
+    entry: [string, Benchmark] | undefined,
+  ): { name: string; value: string } | null {
+    if (!entry) return null;
+    const [, bench] = entry;
+    const best = sortedResults(liveResults(bench), bench.higherIsBetter)[0];
+    if (!best) return null;
+    return { name: best.name, value: fmtDataValue(best.ms.p50, bench.unit) };
+  }
+
+  const groups: DataApiGroupRow[] = GROUP_ORDER.map((g) => ({
+    group: g,
+    benches: groupBenches[g],
+  })).filter((g) => g.benches.length > 0);
+
+  return {
+    groups,
+    providers: providerRows,
+    totals: {
+      uniqueProviders: providerMap.size,
+      benchCount: loaded.length,
+      groupCount: groups.length,
+      headlinePriceFeed: headlineStat(headLagEntry),
+      headlineIndexing: headlineStat(indexingEntry),
+    },
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+export const fetchDataApiSnapshot = unstable_cache(
+  buildSnapshot,
+  ["data-api-cohort"],
+  { revalidate: 60, tags: ["data-api-cohort"] },
+);
diff --git a/src/lib/pm-stats.ts b/src/lib/pm-stats.ts
index bfaff899..26dd8f60 100644
--- a/src/lib/pm-stats.ts
+++ b/src/lib/pm-stats.ts
@@ -74,10 +74,11 @@ type DataFeedSeed = {
 };
 
 const PM_VENUES: VenueSeed[] = [
-  { slug: "polymarket", name: "Polymarket", type: "onchain",  chain: "polygon" },
-  { slug: "kalshi",     name: "Kalshi",     type: "offchain" },
-  { slug: "limitless",  name: "Limitless",  type: "onchain",  chain: "base" },
-  { slug: "myriad",     name: "Myriad",     type: "onchain",  chain: "abstract" },
+  { slug: "polymarket",    name: "Polymarket",    type: "onchain",  chain: "polygon" },
+  { slug: "polymarket-us", name: "Polymarket US", type: "offchain" },
+  { slug: "kalshi",        name: "Kalshi",        type: "offchain" },
+  { slug: "limitless",     name: "Limitless",     type: "onchain",  chain: "base" },
+  { slug: "myriad",        name: "Myriad",        type: "onchain",  chain: "abstract" },
 ];
 
 const PM_DATA_FEEDS: DataFeedSeed[] = [