The Crypto Portfolio API Benchmark · Portfolio Provider Benchmark

Executive summary

What the data says

We run seventeen real-world wallets through nine portfolio APIs — one address at a time — and diff the results. The single biggest differentiator is DeFi decoding: whether an API turns a wallet's on-chain positions — lending, LP, staking, perps, options — into a portfolio, or just lists raw token balances. That one capability moves reported net worth by 10× to 600× on active wallets.

10–600×

net-worth gap between DeFi-decoding and token-only APIs on active wallets

1 of 9

APIs that decode on-chain options (Derive) — the rest see only the collateral

0.2%

spread on a clean single-protocol wallet — proof the deltas are coverage, not noise

Five findings

DeFi decoding is the dividing line. On the multi-sector whale, token-only APIs report $612.6k–$28.60M against $46.27M from the full-portfolio APIs.
Options and perps are barely covered. Only Octav decodes the Derive options book ($1.33M vs ~$401.6k elsewhere).
Solana DeFi is uneven. Octav reads it most completely; Nansen and Solana-only TopLedger also decode Kamino; most others see only the token side; DeBank and Dune don't cover Solana.
Even strong APIs disagree. On the yield wallet, coverage ranges from $1.43M to $3.48M — the difference is Pendle LP valuation.
Price is not the same as coverage. A clean Aave wallet reconciles across every EVM API to within 0.2%; the gaps elsewhere come from what each API sees, not how it prices.

How to read this report

It is organised by capability (coverage, DeFi decoding, options, Solana, performance, cost, developer experience) rather than provider-by-provider, so you can weigh the dimensions that matter for your use case. Every figure is drawn from a single time-aligned snapshot captured 2026-07-13; the harness that produced it is open source. Octav publishes this report and is included in it — see Methodology & disclosure. We flag every place a number is estimated or a provider's own data is anomalous.

Executive summary · at a glance

The field, ranked by use case

There is no single winner — the right API depends on what you're building. The weighted leaderboard (full rubric on the scoring page) is shown alongside, but the use-case picks below matter more.

OctavDeepest DeFi + options + Solana

Only API that decodes options, perps and Solana DeFi in one call — with a per-asset price source.

DeBankEVM DeFi gold standard

Ties for the richest EVM decoding (health rates, perps, vesting); EVM-only, no Solana.

ZerionFastest & cheapest full portfolio

One call, ~320 ms, ~$0.0006 — strong all-round coverage, NFTs and PnL.

DuneCheapest at scale (token data)

Free Sim tier for token balances across 95 chains; no DeFi decoding.

Weighted overall score (measured; rubric disclosed)

DeBank

85

Octav

82

Zerion

79

Mobula

75

TopLedger

67

Zapper

57

Nansen

56

Dune

50

GoldRush

42

Dimensions: coverage 25 · DeFi 20 · chains 15 · cost 15 · performance 10 · DevX 8 · tooling 5 · features 2.

Reading the numbers honestly

Two providers returned anomalous values we kept rather than hide: Mobula mispriced a dead token (LUNC) into an astronomical total on one wallet, and Nansen double-counts a receipt token when its two portfolio endpoints are merged. Both are real, reproducible behaviours, flagged wherever they appear. See Data-quality gotchas.

01 · Introduction

Why we built this

Portfolio APIs all promise the same thing — "give us an address, we'll give you the portfolio." In practice they disagree wildly. We wanted to know exactly how, and by how much, for two reasons.

Reason one

To make our own data better

Octav builds portfolio infrastructure. The fastest way to find our own blind spots is to line our output up against everyone else's on the same wallets. Building this benchmark already surfaced — and let us fix — a real parsing bug and a timeout behaviour on our side. Measuring competitors is how we pressure-test ourselves: where do we miss a protocol, mis-price a token, or under-cover a chain?

Reason two

To publish a transparent benchmark

Anyone choosing a portfolio API today has to trust marketing pages. There is no neutral, reproducible comparison of what these APIs actually return for real wallets. So we built one — with an open app you can run on any address, an open capture harness, and a commitment to report the numbers as they fall, including where Octav loses.

The question that matters

A "portfolio" is more than a list of tokens. A serious wallet has money working inside protocols — supplied to Aave, LP'd in a Pendle pool, staked in EigenLayer, held as a Hyperliquid perp or a Derive option. The core question this report answers is simple: which APIs actually see that money, and which only see the tokens sitting idle in the wallet?

To answer it we assembled seventeen wallets that each stress a different capability — from a single clean Aave deposit (where everyone should agree) to a 54-protocol, 19-chain whale (where they don't) to Solana-native DeFi (where most EVM-first APIs go blind, and one — TopLedger — is a Solana specialist). We then called every applicable API on each, at approximately the same moment, and measured everything.

What "we" means here

This report is published by Octav, which is one of the nine APIs measured. We've tried hard to earn your trust rather than assume it: the harness is open, the rubric is disclosed, Octav's numbers get no special treatment, and we lead with use-case fit rather than a single trophy. Where Octav is slower or more expensive than a rival, the report says so plainly.

02 · Methodology

How we measured

One backend, one entry point, one snapshot. Every provider is called through the same normaliser so results diff apples-to-apples, and every raw payload is cached so any number can be re-derived without spending an API credit.

Single entry point

Each API sits behind one adapter that returns a normalised portfolio (tokens + decoded protocol positions). The frontend calls one endpoint; differences are the providers', not our plumbing.

Time-aligned snapshot

The set was captured in waves as it grew: the six original EVM wallets on 2026-07-02, the six Solana wallets on 2026-07-13, and five larger EVM wallets on 2026-07-13. Within each wave every provider is called in one pass, so results diff apples-to-apples. Latency is the provider's measured response time.

Reconciled & reproducible

Where an API exposes its own net-worth total we cross-check our parse against it (Octav, Zapper and Mobula reconcile to 0.0%). Raw payloads are cached; the harness is open source.

The seventeen wallet archetypes

Archetype	Chain	What it stresses
Multi-sector whale	EVM	54 protocols across 19 chains — lending, LP, staking, perps, options, prediction markets.
Options trader	EVM	Large on-chain options book on Derive (Lyra v2) plus vesting and staking.
Lending whale	EVM	Single, clean Aave V3 USDC supply — the control case where everyone should agree.
Yield / restaking	EVM	Pendle LP + Ethena + Swell/Renzo restaking — yield-token valuation stress test.
Curve / Convex farmer	EVM	Deep Curve/Convex/Frax LP + gauge positions across many pools.
Retail power user	EVM	Realistic retail wallet: DeFi + perps + options + Polymarket at small scale.
Nine-figure whale	EVM	$100M+ across Hyperliquid perps, Aave/Morpho lending, Lyra options and Pendle.
HyperEVM whale	EVM	HyperEVM-native DeFi (Kinetiq, HyperLend, Hyperbeat) plus Hyperliquid and restaking.
Aave + Lido whale	EVM	Concentrated Aave V3 supply plus a large Lido staking position.
LST + lending mix	EVM	Sky, Aave, Lido, ether.fi and Kelp: liquid staking blended with lending.
Restaking whale	EVM	ether.fi + Karak + Puffer + Swell + EigenLayer liquid restaking across LRTs.
Solana DeFi whale	SOL	Multi-million Kamino lending book plus LSTs and SPL tokens.
Solana all-rounder	SOL	Jupiter Lend + Kamino + Drift + Jito across many SPL tokens.
Solana leveraged loop	SOL	Leveraged Kamino position (health rate 0.09) — value locked inside the protocol.
Solana Jupiter Perps	SOL	Near-pure Jupiter Perps book — tests perp collateral vs marked-to-market unrealized PnL.
Solana multi-protocol	SOL	Drift + Jupiter Perps + Marginfi + Meteora + native stake — Solana breadth across 5+ protocols.
Solana Jupiter degen	SOL	Jupiter Perps + offerbook + JUP DAO + Kamino + Meteora DLMM + Jupiter Lend + Pyth — max-protocol wallet.

What we deliberately did not do

We did not tune any adapter to flatter a provider, and we did not "correct" a provider's own data. When an API returns an anomalous value, we keep it and flag it. Cost figures are normalised to a single-address fetch from each provider's published pricing (verified against live docs where possible) and marked estimated where a rate is not public. Some capabilities — NFT valuation depth, historical accuracy — are out of scope for this edition and noted in Limitations.

03 · The contenders

Nine portfolio APIs

They fall into four families: full-portfolio APIs that decode DeFi positions, an analytics platform with a portfolio endpoint, token-data APIs that return balances only, and a Solana-only DeFi specialist. That family line predicts most of what follows.

Provider	Category	EVM	SOL	DeFi	Chains	Calls	Pricing model
Octav 1-call full portfolio + price source	Full portfolio	✓	✓	✓	74+	1	Credits (never expire)
DeBank DeFi-position gold standard (EVM)	Full portfolio	✓	–	✓	84+	3	Prepaid Units
Zerion Fast 1-call, cheap, NFTs + PnL	Full portfolio	✓	✓	✓	64+	1	Subscription + quota
Zapper GraphQL portfolioV2, 60+ chains	Full portfolio	✓	✓	✓	56+	1–4	Credits (3/query)
Mobula Cheap multichain, built-in PnL	Full portfolio	✓	✓	✓	88+	2	Credits (1/chain)
Nansen Analytics-grade, labels, SOL DeFi	Analytics + portfolio	✓	✓	✓	37+	2	Credits + subs
Dune Sim API — token balances (free tier)	Wallet data API	✓	–	–	95+	1+	Sim free tier
GoldRush Token balances, EVM + Solana	RPC · token API	✓	✓	–	100+	4 multichain · 1 SOL	Credits
TopLedger Solana-only DeFi position analytics	Solana DeFi analytics	–	✓	✓	1+	2	Pay-per-call (Pay.sh)

✓ supported– not supported Calls = requests to assemble a full portfolio for one address

Full portfolio

Octav · DeBank · Zerion · Zapper · Mobula — decode wallet tokens and protocol positions. The question is how deep and across which chains.

Analytics + portfolio

Nansen — analytics-grade with labels and a DeFi-holdings endpoint; priciest per call, no token logos, strong on Solana.

Token data

Dune · GoldRush — accurate token balances and prices across many chains, but no DeFi decoding. Excellent baselines; not full portfolios.

Solana DeFi specialist

TopLedger — decodes Solana DeFi positions by category (lending, perps, LP, staking, DAO) for a fraction of a cent, but Solana-only, and its /holdings token endpoint returned empty for our test wallets.

04 · The heart · Coverage & accuracy

Who sees the whole wallet

Coverage is the headline. On our multi-sector whale — 54 protocols across 19 chains — full-portfolio APIs land near $46.27M, while token-only APIs see a rounding error of it.

Fig. 1 — Reported net worth for the multi-sector whale (0x3e87…d90c). Token-only APIs (Dune, and GoldRush's EVM tokens) miss the DeFi positions that hold most of the value.

Coverage across every wallet

Each cell = the share of the reference net worth — the Octav + DeBank consensus (the two full-portfolio APIs that agree and decode each asset once) — that a provider captured. Darker = more complete. Over 100% means over-counting, not extra coverage (see below). "!" = anomalous payload; "–" = not supported.

Wallet	Octav	DeBank	Zerion	Zapper	Nansen	Mobula	GoldRush	Dune	TopLedger
Multi-whale	100%	100%	97%	76%	76%	62%	62%	1%	–
Options	100%	34%	34%	30%	33%	30%	30%	30%	–
Lending	100%	100%	100%	102%	205%	102%	102%	102%	–
Yield	100%	100%	100%	53%	54%	41%	42%	42%	–
Curve	100%	100%	82%	83%	48%	!	0%	0%	–
Retail	99%	100%	48%	50%	49%	31%	2%	37%	–
Mega-whale	100%	92%	33%	61%	7%	!	0%	1%	–
HyperEVM	100%	100%	141%	3%	67%	!	0%	70%	–
Aave+Lido	100%	100%	100%	0%	109%	!	109%	39%	–
LST mix	100%	100%	120%	0%	50%	84%	0%	65%	–
Restaking	100%	100%	99%	86%	98%	!	98%	96%	–
SOL whale	100%	–	38%	0%	67%	38%	38%	–	83%
SOL all-round	100%	–	7%	0%	11%	13%	7%	–	2%
SOL loop	100%	–	0%	0%	99%	0%	0%	–	103%
SOL perps	100%	–	0%	0%	84%	1%	0%	–	111%
SOL degen	100%	–	27%	0%	101%	28%	27%	–	8%
SOL Jup	100%	–	7%	0%	84%	118%	0%	–	57%

04 · The heart · Coverage & accuracy (cont.)

Reading the heatmap honestly

A coverage number can be off in two directions. Some providers miss value (token-only reads of a DeFi wallet); others over-count it. We keep every raw number and explain the outliers rather than quietly correct them.

Over 100% — double-counted receipt tokens

Zerion runs over 100% on the LST/vault wallets because it counts a liquid-staking or vault receipt token as a wallet holding and again as the decoded protocol position. On the HyperEVM whale it lists Kinetiq's $13.27M vkHYPE receipt as a loose token and books the Kinetiq position ($15.90M) — the same money twice — for $45.89M vs the $32.50M consensus. Same on the LST mix (sGHO, stETH). Nansen does the same with an aToken, up to 205% on the clean Aave wallet. Octav and DeBank decode each asset once, so they sit at 100%.

"!" — mispriced dead tokens

Mobula occasionally attaches an absurd unit price to one defunct long-tail token, blowing up the total: ~10⁴⁶ on the mega-whale and HyperEVM whale, and ~24× the consensus on the Aave+Lido and restaking wallets. Any payload above 3× the reference (or astronomically large) is flagged "!" and dropped from the coverage colour — it is a real Mobula data issue, kept but not plotted.

Low cells — genuine under-coverage

The small percentages are the real coverage gaps this benchmark exists to show. On the HyperEVM whale, Zapper sees 2% and GoldRush/Dune a rounding error, because they read tokens but don't decode HyperEVM-native protocols (Kinetiq, HyperLend, Hyperbeat); Nansen lands near 67% for the same reason. Under-counting, not over-counting, is the more common failure — and the one that matters most for a portfolio.

The control case

On the lending whale — a single clean Aave V3 USDC supply — every EVM API agrees to within 0.2% ($83.64M ±). That is the point: when the wallet is simple, everyone is accurate — proving the large gaps elsewhere are about coverage of complex positions (or the double-counts above), not price noise.

05 · The heart · DeFi decoding

The dividing line

Decoding a position means turning a receipt token (aUSDC, a Pendle LP, a Kamino obligation) back into what it represents — a supply, a debt, an LP with underlying assets, a reward. It is the single capability that separates a portfolio API from a token API.

Provider	Decodes DeFi	Positions seen*	Health rate	Price source	Depth
Octav	✓	614	✓	✓	Lending, LP, staking, perps, options, prediction mkts
DeBank	✓	584	✓	–	Lending, LP, staking, perps, options, vesting (EVM)
Zerion	✓	531	–	–	Lending, LP, staking, deposits (+NFTs, PnL)
Zapper	✓	123	–	–	Apps + positions; weak on Pendle-style yield tokens
Mobula	✓	1	–	–	Advertised; inconsistent run-to-run this benchmark
Nansen	✓	47	–	–	DeFi-holdings endpoint; strong on Solana, misses some LP
TopLedger	✓	12	–	–	Solana only — lending, perps, LP, staking, DAO by category; /holdings token endpoint empty in tests
Dune	–	0	–	–	None — token balances only
GoldRush	–	0	–	–	None — token balances only (DeFi endpoints deprecated)

* Total decoded protocol positions across the seventeen test wallets.

Mobula advertises DeFi but returned no positions on several wallets this run — see below.

TopLedger is Solana-only, so it decodes on the six Solana wallets.

What good decoding looks like

On the yield wallet, Octav, DeBank and Zerion value the Pendle LP correctly (~$3.48M total). Zapper and Nansen show the Pendle app but price the LP token at a few thousand dollars — a known weak spot for yield-token valuation — landing near $1.85M.

Inconsistency is real

Mobula returned a full DeFi breakdown on one snapshot and an empty one on the next for the same wallet ($3.86M → $1.43M). If you depend on DeFi positions, run-to-run stability matters as much as peak coverage.

Beyond value: what the position tells you

Two APIs go further than a dollar figure. Octav and DeBank return a health rate for leveraged positions (how close to liquidation), and Octav attaches a per-asset price source so you can audit where a valuation came from — the only API in the set that does.

06 · The heart · Derivatives

Options & perps: the blind spot

On-chain derivatives are where coverage collapses. Our options trader holds a large book on Derive (Lyra v2). Only one API turns that book into portfolio value; the rest see the collateral sitting in the wallet and stop there.

Fig. 2 — Options trader (0x43a9…ed7).

Octav decodes the Derive options position ($1.33M); every other API reports roughly the wallet-token value (~$401.6k), a 3.3× difference.

Options

Only Octav decodes the Derive book. DeBank and Zerion catch part of the collateral (~$449.2k); the token-only APIs see just the wallet tokens. For anyone tracking structured-product or options desks, this is the difference between a real number and a wrong one.

Perps

Perpetuals fare a little better. On the retail wallet, Octav and DeBank decode the Hyperliquid and Lighter positions others miss, which is why they report $56.0k against ~$27.4k from the DeFi-lite APIs. Perp equity vs. open-notional accounting also varies between providers — worth verifying per API.

Why this matters disproportionately

Derivatives concentrate a lot of value in a few positions. An API that misses them doesn't just lose a line item — it can under-report a serious trader's net worth by an order of magnitude, as Fig. 2 shows.

07 · The heart · Solana

Solana splits the field

Solana is where the field splits hardest. Two of nine — DeBank and Dune — don't support it at all. Of the rest, Octav reads it most completely; the others diverge sharply on how much Solana DeFi they decode versus just listing SPL balances — including a Solana-only entrant, TopLedger.

Fig. 3 — Solana DeFi whale (4yhX…Z3do), a mostly-Kamino book, bars sorted by reported value.

Octav ($23.39M) reads it most completely;

TopLedger ($19.53M) and

Nansen ($15.68M) decode the Kamino book — TopLedger, decoding only Kamino, edges Nansen here because Kamino is the wallet; token-focused reads land near $8.98M;

DeBank and

Dune are EVM-only;

Zapper returned $0 on every Solana wallet this run.

Decode Solana DeFi

Octav, Nansen and TopLedger turn Kamino/Jupiter/Drift positions into value. On the leveraged loop wallet they report $229.1k / $225.7k / $236.9k while token-only reads see ~$0.

Token side only

Zerion, Mobula and GoldRush return Solana SPL balances accurately (all ~$8.98M on the whale's token side) but miss the value locked in protocols.

No Solana

DeBank (EVM DeFi specialist) and Dune (Sim) don't cover Solana at all — a hard gap for any multi-chain product that includes SOL users.

The takeaway

If Solana matters to you, the field shrinks fast. Full Solana DeFi coverage in the same call as EVM is rare — in this set, Octav and Nansen — and only Octav does it while also decoding EVM options and perps. TopLedger decodes deep Solana DeFi too, but Solana only — the next page reads all of them, wallet by wallet.

07 · The heart · Solana (cont.)

Reading Solana, provider by provider

Octav reads Solana the most completely — it decodes every protocol in the set and returns loose token holdings, so it is the fullest picture on all six wallets. Everyone else trades coverage for something. Here is what each Solana-capable API reported for the six Solana wallets; each cell is shaded against the highest value in its row.

Wallet	Octav	Nansen	TopLedger	Zerion	Mobula	GoldRush	Zapper
SOL whale	$23.39M	$15.68M	$19.53M	$8.98M	$8.98M	$8.96M	$0
SOL all-round	$3.33M	$376.8k	$65.5k	$229.2k	$419.1k	$227.0k	$0
SOL loop	$229.1k	$225.7k	$236.9k	$55	$157	$46	$0
SOL perps	$24.1k	$20.1k	$26.7k	$119	$127	$118	$0
SOL degen	$83.7k	$84.2k	$7.0k	$23.0k	$23.1k	$23.0k	$0
SOL Jup	$40.2k	$33.5k	$23.1k	$2.7k	$47.5k	$103	$0

Darker = closer to the row's best read.

DeBank and

Dune are omitted — they don't support Solana.

Zapper returned $0 on every Solana wallet this run (a live outage, not a coverage limit).

Deepest & broadest — Octav

Decodes Kamino, Jupiter (Perps and Lend), Drift, Marginfi, Meteora, staking, governance — and lists the loose SPL tokens the others drop. On the all-rounder it captures $3.33M where the next-best DeFi read sees a fraction.

Also decode SOL DeFi — Nansen & TopLedger

Nansen is the closest to Octav — it even catches Drift (multi-degen $84.2k ≈ Octav $83.7k). TopLedger is strong on Kamino, Jupiter Perps and Marginfi (it out-reads Nansen on the Kamino whale) but misses Jupiter Lend and Drift.

Token balances only

Zerion, Mobula and GoldRush return Solana SPL balances accurately (~$8.98M on the whale's token side) but decode no DeFi positions — so on Kamino/Jupiter-heavy wallets they read a small fraction of the true value.

Two things to know about TopLedger, the Solana-only entrant

1 · Perp value is collateral, not mark-to-market. It reports a perp's deposited collateral and returns unrealized PnL as a separate field it does not fold into net worth — so on the Jupiter Perps trader it shows $26.7k vs Octav's marked-to-market $24.1k (the gap is an open loss), and under-states a winning book. A convention choice (collateral-at-risk vs closeable equity), not an error. 2 · It has a wallet-token endpoint (/holdings), which we call — but it returned empty for every wallet we tested (even ones holding millions in loose SPL elsewhere), so its totals here are DeFi-position value only. Its footprint is protocol-shaped: near-complete on Kamino/Jupiter-Perps/Marginfi, thin where value sits in Jupiter Lend, Drift or loose tokens — pair it with a token API.

08 · The heart · Tokens & chains

Breadth of tokens and chains

Coverage isn't only about DeFi — it's also how many chains an API reaches and how well it filters spam. We don't score raw token counts (a wallet with 1,100 memecoins isn't "richer"); we report supported chains and what each API actually returned across the test set.

Provider	Chains supported	EVM	Solana	Tokens returned*	Max chains / wallet
Octav	74+	✓	✓	619	37
DeBank	84+	✓	–	585	48
Zerion	64+	✓	✓	612	26
Zapper	56+	✓	✓	216	15
Mobula	88+	✓	✓	557	9
Nansen	37+	✓	✓	503	14
Dune	95+	✓	–	496	13
GoldRush	100+	✓	✓	266	15
TopLedger	1+	–	✓	0	1

* Summed across the seventeen wallets after each provider's own spam filtering. Higher isn't automatically better — it reflects both reach and how aggressively an API filters dust.

Chain reach vs. chain depth

Several APIs advertise 80–100+ chains, but reach is not depth: GoldRush and Dune cover many chains for tokens yet none for DeFi. The full-portfolio APIs cover fewer chains but decode positions on them — the more useful kind of breadth.

One call vs. many

Octav and Zerion return every chain in a single call. GoldRush batches its chains through a multichain endpoint (10 per call), and Dune paginates — which shows up directly in the latency and cost pages that follow.

09 · The heart · Performance

Speed, calls & payload size

A portfolio call sits in a user's critical path, so latency and request count matter. The spread is wide: from a single ~320 ms round-trip to multi-second, multi-call assemblies.

Fig. 4 — Median response time per provider across the test wallets, annotated with average calls per portfolio. One-call APIs cluster at the top; fan-out and heavy-sync APIs trail.

Latency is the wall-clock time to assemble the full portfolio. For multi-call APIs, independent requests are issued in parallel, so the figure reflects concurrent execution — not the sum of each call. Call counts are averaged across the seventeen wallets, so they read as fractional: larger wallets trigger extra pagination pages and per-chain providers fan out, so the same API can make a different number of calls per wallet.

Fastest

Zerion

~320 ms in a single call — the performance leader, even on large wallets.

Heaviest payloads

Zerion

Speed has a cost: Zerion returns the largest payloads (~750 KB avg), including one ~62 MB Solana response.

Depth over raw speed

Octav

Octav returns everything in one call but decodes deeply, so it can be slower on very large wallets.

Depth and breadth both cost latency

Latency tracks how much each API does per call — in two ways. The APIs that decode positions do more work, so the deepest can be slower on the largest wallets. And the APIs that query many chains pay for breadth: GoldRush is token-only yet the slowest here because it sweeps all ~39 EVM chains through the multichain endpoint. Both are trade-offs to weigh against how complete you need the portfolio to be.

10 · The heart · Cost

What it costs at scale

Pricing models don't compare directly — credits, prepaid units, compute units, subscriptions. We normalise to $ per portfolio fetch, counting how many calls each API needs and how many credits those calls cost (they're rarely 1:1), at each provider's first paid package.

Provider	Pricing model	Calls / fetch	$/fetch	1k / mo	100k / mo	1M / mo	Our test cost
Dune	Free CU tier^a	1–5	$0	$0	$0	$0	$0
Zerion	Subscription (Builder)	1	$0.0006	$0.6	$60	$600	$0.005
TopLedger	Pay-per-call (Pay.sh)^e	2	$0.0008	$0.8	$80	$800	$0.0048
Zapper	Credits (3/query)^b	1–4	$0.0031	$3	$307	$3,070	$0.03
Mobula	Credits (1/chain)^b	2	$0.0051	$5	$511	$5,110	$0.05
GoldRush	Credits^b	4·1	$0.0070	$7	$700	$7,000	$0.06
DeBank	Prepaid Units^c	3	$0.0116	$12	$1,160	$11,600	$0.1
Octav	Credits (never expire)	1	$0.0250	$25	$2,500	$20,000	$0.23
Nansen	Credits + subs (Pro)^d	2	$0.0544	$54	$5,440	$54,400	$0.49

Verified against live pricing 2026-07-02. First paid package, no free tier (except

Dune); 1 call ≠ 1 credit — calls are mapped to each provider's billing unit. "Our test cost" = the real credits/units our 9-wallet benchmark consumed × that rate. Octav = ground truth. ^aDune Sim is being sunset 1 Aug 2026. ^bCredit cost is endpoint-dependent (per-chain / per-query). ^cDeBank −20% on ≥$100k prepay. ^dNansen publishes no $/credit; we use its base Pro plan ($49 / 2,000 credits = $0.0245/credit). Enterprise/volume tiers are sales-gated. ^eTopLedger's published Pay.sh rate ($0.0004/call, Solana USDC) × 2 calls/fetch (analyze + holdings); Solana-only, so it runs on the six Solana wallets.

Cheap at scale

Dune is free (token data, but sunsetting); Zerion is the cheapest paid full portfolio (~$0.0006/fetch); Zapper and Mobula stay well under a cent.

Premium

Nansen is the most expensive per fetch (~$0.054 — you pay for analytics and labels); Octav at $0.025 sits mid-high, reflecting the decoding depth per call. Our 9-wallet run costs most on Nansen ($0.49) and Octav ($0.23) — no free tier — but pennies overall.

11 · The heart · Developer experience

How hard is it to integrate

Beyond the data, what is it like to build against? We weigh auth friction, whether a full portfolio is one call or a fan-out, SDK/docs quality, and Solana support — from actually integrating all nine.

Provider	Auth	Calls	DevX score	Integration notes
Octav	Bearer key	1	90	1-call, price source, MCP; slow on huge wallets
Zerion	Basic (key)	1	88	1-call, fast, cheap; large payloads
Mobula	Header key (flexible)	2	80	Cheap, simple; DeFi inconsistent run-to-run
DeBank	AccessKey header	3	78	Rich EVM decoding; 3 calls; EVM-only
Dune	X-Sim-Api-Key	1+	74	Simple, free; token-only; DeFi API sunset
Zapper	x-api-key (GraphQL)	1–4	72	GraphQL flexibility; verbose; Pendle mispriced
Nansen	apikey header	2	66	Two endpoints; merge carefully (double-count)
GoldRush	Bearer key	4 multichain · 1 SOL	60	Multichain balances endpoint; DeFi endpoints deprecated
TopLedger	x-api-key header	2	62	2-call, cheap, clean auth, MCP + streaming; Solana-only, ~24s, /holdings empty in tests

Smoothest to integrate

Octav and Zerion: one call, clean auth, a coherent shape that maps straight onto a normalised portfolio. Mobula is close and cheap. These got us to a correct portfolio fastest.

Sharper edges

GoldRush fans out per chain and its DeFi endpoints are deprecated; Zapper's GraphQL is powerful but verbose and its Pendle valuation is off; Nansen splits a portfolio across two endpoints that double-count if you merge them naively. All integrable — just budget more time.

A note from building it

Every integration gap we hit is documented in the open harness — including bugs we fixed on our own Zerion adapter (a receipt-token double-count) and Octav's timeout behaviour. The DevX scores reflect real integration effort, not marketing claims.

12 · The heart · Tooling

The tooling & agent stack

In 2026 an API is only as good as what you can build against it — and the fastest-moving layer is AI. We surveyed each provider's official SDKs, MCP servers, x402 pay-per-call, AI-agent kits, CLI and streaming (community-only tooling doesn't count).

Provider	SDK	MCP	x402	AI agent	CLI	Stream	Score	Highlights
GoldRush	✓	✓	✓	✓	✓	✓	90	TS + Python SDKs, React kit, MCP, CLI, x402, GraphQL/WS streaming
Zerion	–	✓	✓	✓	✓	✓	86	Hosted MCP, agent skill, CLI, x402, Kafka streams + webhooks
Octav	~	✓	✓	✓	✓	–	82	Community SDK, official MCP (14 tools), Rust CLI, x402, AI-dev docs + skill
TopLedger	~	✓	✓	✓	–	✓	82	Data-infra native: Kafka/real-time streams + SQL pipelines (core product), official MCP (SSE, 10 tools), x402/Pay.sh; no REST SDK/CLI
Zapper	–	✓	✓	✓	–	~	78	Official MCP, x402, agents.txt; GraphQL (no subscriptions)
Nansen	–	✓	✓	✓	✓	–	74	Official MCP, CLI, agent hub, x402; no SDK / streaming
Mobula	✓	–	✓	~	–	✓	64	TS SDK, GraphQL + WebSocket + webhooks, x402; no MCP/CLI
DeBank	~	~	–	–	–	–	40	REST only; SDK & MCP are community, not official
Dune	–	–	–	–	–	~	38	Sim: webhooks only; sunsetting Aug 2026

✓ official~ partial / community – noneMCP = Model Context Protocol server for AI assistants

The MCP + x402 wave

Six of nine ship an official MCP server and seven support x402 pay-per-call (Base/Solana) — the new default for agent access. Octav, Zerion, Zapper, Nansen, GoldRush and TopLedger lead the agent-native shift.

Richest stack

GoldRush is the most complete — official TS + Python SDKs, a React kit, MCP, CLI, x402 and GraphQL-over-WebSocket streaming. Zerion is close and the most AI-forward. TopLedger, a Solana data-infra company at heart, ships Kafka real-time streams and SQL pipelines alongside its MCP — deep tooling for a single-chain API.

Thinnest

DeBank is REST-only with no official SDK/MCP/CLI/x402 (all community). Dune's Sim API offers only webhooks and is sunsetting Aug 2026. Both are usable, but you build the tooling yourself.

Why this is its own dimension

An MCP server or x402 endpoint can turn a week of integration into an afternoon — and increasingly your users' AI agents call these directly. We weight tooling lightly (5%; data still comes first), but it's the fastest-growing reason teams switch providers.

13 · The heart · Data-quality gotchas

Where the data lies (and we kept it)

A benchmark you can trust has to show the ugly parts. Two providers returned values we could have quietly "fixed" — we didn't. Here is exactly what happened and how to defend against it in production.

Mobula — mispriced dead tokens (recurring)

On the Curve farmer, Mobula returned a unit price of ~3.2×10¹⁸ for LUNC (a defunct token), producing a portfolio total of ~10²³ dollars. It is not a one-off: on the larger EVM wallets we added, Mobula again blew up the total (~10⁴⁶ on the mega-whale, ~10⁴⁰ on the HyperEVM whale) or overstated it ~24× (the Aave+Lido and restaking wallets), each time from a single bad long-tail price. We keep the raw numbers and flag them out of the charts — real Mobula data issues, not ours. Defence: sanity-bound unit prices and cross-check long-tail tokens against a second source.

Nansen — a double-counted receipt token

Nansen splits a portfolio across two endpoints: token balances and DeFi holdings. On the Aave wallet the aUSDC receipt token appears in both — once as a wallet token and again as the decoded Aave position — so a naive merge reports ~205% of the true value ($171M vs ~$84M). It only surfaces when a receipt token lands in the balance list. We keep it and flag it as an integration gotcha. Defence: dedupe receipt tokens that also appear as protocol positions.

What this says about the field

Neither issue is exotic — a bad long-tail price and an endpoint-merge double-count are exactly the failure modes you inherit in production. The lesson isn't "these two are bad"; it's that every portfolio API needs sanity checks around it, and an API that decodes positions and exposes its price source (only Octav here) makes those checks easier.

14 · Scoring

A transparent scorecard

We resisted reducing this to one number, but a disclosed rubric is useful if you read it as a starting point, not a verdict. Each dimension is scored 0–100 from the measured data; the overall is a weighted sum. Re-weight it for your use case and the order changes.

25%

Coverage

20%

DeFi decoding

15%

Chain breadth

15%

Cost efficiency

10%

Performance

8%

Developer exp.

5%

Tooling

2%

Features

Provider	Coverage	DeFi	Chain	Cost	Perf	Developer	Tooling	Features	Overall
DeBank	100	100	80	79	69	78	40	63	85
Octav	100	100	78	54	40	90	82	75	82
Zerion	48	100	69	99	92	88	86	50	79
Mobula	40	100	92	91	67	80	64	63	75
TopLedger	70	100	9	99	33	62	82	38	67
Zapper	3	100	61	94	27	72	78	38	57
Nansen	67	100	43	0	30	66	74	25	56
Dune	39	0	90	100	33	74	38	25	50
GoldRush	7	0	100	87	26	60	90	25	42

Weights: coverage 25 · DeFi 20 · chains 15 · cost 15 · performance 10 · DevX 8 · tooling 5 · features 2. Coverage uses the Octav + DeBank consensus per wallet (the two full-portfolio APIs that agree and decode each asset once), so no single provider is ground truth.

Read it as a spread, not a podium

The top three (DeBank 85 · Octav 82 · Zerion 79) are within a few points and win on different axes: DeBank and Octav tie on coverage and DeFi decoding, with DeBank edging ahead on chain breadth and cost and Octav leading on developer experience, Solana and its unique price source; Zerion wins on raw speed and cost. Weight the dimensions you actually ship on and pick accordingly — which is what the next page does.

15 · Provider scorecards

Provider scorecards

Strengths, watch-outs and the use case each API is genuinely best for.

DeBankFull portfolio

85/100

DeFi-position gold standard (EVM) · 84+ chains · EVM · 3 call(s) · $0.0116/fetch

Strengths

Richest EVM DeFi decoding (perps, options, vesting)
Health rates; strong reconciliation
Fast (~1 s), 3 clean calls

Watch-outs

EVM-only — no Solana
Prepaid-units billing
No price source / PnL

Best for: EVM-first products that want gold-standard DeFi decoding and don't need Solana.

OctavFull portfolio

82/100

1-call full portfolio + price source · 74+ chains · EVM + Solana · 1 call(s) · $0.025/fetch

Strengths

Only API to decode options, perps & Solana DeFi in one call
Per-asset price source + health rates
Reconciles to its own totals at 0.0%

Watch-outs

Mid-high cost (~$0.025)
Can be slower on very large wallets
No NFTs

Best for: Products needing the deepest, broadest single-call coverage — derivatives, Solana DeFi, multi-chain net worth.

ZerionFull portfolio

79/100

Fast 1-call, cheap, NFTs + PnL · 64+ chains · EVM + Solana · 1 call(s) · $0.0006/fetch

Strengths

Fastest (~320 ms), one call
Cheapest paid full portfolio (~$0.0006)
NFTs + PnL + 24h change; EVM & Solana tokens

Watch-outs

Very large payloads (up to ~62 MB)
Misses options/perps & most Solana DeFi
Subscription quota limits

Best for: Consumer apps that need a fast, cheap, broad portfolio and can live without derivative/Solana-DeFi depth.

MobulaFull portfolio

75/100

Cheap multichain, built-in PnL · 88+ chains · EVM + Solana · 2 call(s) · $0.0051/fetch

Strengths

Cheap multichain incl. Solana
Built-in PnL & allocations
Simple, flexible auth

Watch-outs

DeFi coverage inconsistent run-to-run
Long-tail price outliers (LUNC)
Weaker decoding depth

Best for: Cost-sensitive multichain apps that need tokens + light DeFi and add their own sanity checks.

TopLedgerSolana DeFi analytics

67/100

Solana-only DeFi position analytics · 1+ chains · + Solana · 2 call(s) · $0.0008/fetch

Strengths

Decodes Solana DeFi by category (lending, perps, LP, staking, DAO)
Very cheap (~$0.0008, 2 calls) + official MCP & Kafka streams
Strong on Kamino, Jupiter Perps, Marginfi, Meteora

Watch-outs

Solana-only; slowest here (~24 s/call)
/holdings token endpoint returned empty in tests; misses Jupiter Lend & Drift
Perps valued at collateral, not marked-to-market; no health rate

Best for: Solana-native agents and dashboards that need decoded DeFi positions cheaply — paired with a token-balance source.

15 · Provider scorecards (cont.)

ZapperFull portfolio

57/100

GraphQL portfolioV2, 60+ chains · 56+ chains · EVM + Solana · 1–4 call(s) · $0.0031/fetch

Strengths

GraphQL flexibility, 60+ chains incl. Solana
Decodes most EVM DeFi + NFTs
Field-selectable payloads

Watch-outs

Under-values Pendle-style yield tokens
3–4 calls, slower
Verbose to integrate

Best for: Apps already on GraphQL that want broad app coverage and can tolerate yield-token gaps.

NansenAnalytics + portfolio

56/100

Analytics-grade, labels, SOL DeFi · 37+ chains · EVM + Solana · 2 call(s) · $0.054/fetch

Strengths

Decodes Solana DeFi (Kamino, Drift)
Analytics, labels, smart-money context
Broad chain set

Watch-outs

Most expensive (~$0.054)
Two endpoints double-count if merged naively
No token logos

Best for: Analytics and intelligence products where labels and Solana DeFi matter more than price.

DuneWallet data API

50/100

Sim API — token balances (free tier) · 95+ chains · EVM · 1+ call(s) · $0 (free tier)

Strengths

Free at benchmark scale
Token balances across 95 chains
Simple auth, reliable

Watch-outs

No DeFi decoding at all
EVM-only
DeFi Positions API sunset

Best for: Dashboards and internal tools that need cheap, wide token balances and no protocol positions.

GoldRushRPC · token API

42/100

Token balances, EVM + Solana · 100+ chains · EVM + Solana · 4 multichain · 1 SOL call(s) · $0.007/fetch

Strengths

Token balances across EVM + Solana
Multichain endpoint — all EVM chains in a few calls
Broad chain coverage

Watch-outs

No DeFi decoding (endpoints deprecated)
Slow — full-chain multichain query ~13 s
Trial keys suspend under bursts

Best for: Token-balance baselines and multi-chain wallet views where DeFi positions aren't required.

16 · Limitations

What we couldn't measure

Honesty about scope is part of a credible benchmark. This edition has real boundaries.

Seventeen wallets, captured in waves. The set grew over three capture passes (original EVM 2026-07-02, Solana 2026-07-13, five larger EVM wallets 2026-07-13). Within each wave every provider is called in one pass, so results are time-aligned; recurring/streaming accuracy and cold-start behaviour over days are not captured here.
Cost is normalised, not billed. We convert each provider's published pricing to $/fetch; real invoices depend on plan tier, volume discounts and caching. Figures marked estimated are not official.
NFTs are out of scope. Only some APIs value NFTs and methods vary wildly, so we excluded them to keep the net-worth comparison fair. A future edition may add an NFT track.
Reference, not truth. "Coverage %" is measured against the Octav + DeBank consensus (which agree and decode each asset once), not an absolute ground truth — no oracle exists for a live wallet's true net worth.
Perp accounting varies. Equity vs. open-notional conventions differ between APIs; we report totals as returned and flag the ambiguity rather than force a convention.
Provider plans differ. Some capabilities (labels, extra chains, streaming) sit behind higher tiers than the keys we tested; where a product exists but our key couldn't reach it, we say so.

Everything here is reproducible

The capture harness, the normaliser, the scoring rubric and this generator are open. Run the app on your own address, or re-run the benchmark, and you'll get these numbers — or newer ones.

17 · Conclusion

Pick by what you're building

There is no universal best portfolio API — there is a best one for your use case. The data points to clear picks.

Octav

You need the deepest, broadest coverage

Options, perps, Solana DeFi and EVM DeFi in one call, with a price source to audit valuations. You pay for it in cost and, on giant wallets, latency.

DeBank

You're EVM-only and want gold-standard DeFi

The richest EVM decoding in the set. Skip it only because you need Solana or a price source.

Zerion

You want fast, cheap and broad

One ~320 ms call, ~$0.0006, NFTs and PnL. Accept that options, perps and Solana DeFi won't be decoded.

Dune

You just need token balances cheaply

Free Sim tier, 95 chains, dead simple — as long as you never need a decoded DeFi position.

The one thing to take away

Decide first whether you need positions or just balances. That single choice removes half the field. If you need positions — and any serious wallet has them — the depth of DeFi, options, perps and Solana decoding is what separates a portfolio that's right from one that's off by an order of magnitude. Everything else — cost, speed, DevX — is a tie-breaker among the APIs that clear that bar.

Why we're comfortable publishing this

Octav places well here on coverage and decoding, and worse on cost and raw speed — and we've shown both. If the numbers ever stop favouring an honest read, the harness is open for anyone to check. That's the point: a benchmark is only worth something if you can reproduce it.

Appendix · Wallets tested

The wallets we benchmarked

Every figure in this report is derived from these exact addresses — eleven EVM and six Solana — so anyone can reproduce or challenge the numbers. Paste any of them into benchmark.octav.fi or an explorer to verify.

Archetype	Chain	Address
Multi-sector whale $44M, 93 tokens, 54 protocols, 19 chains — perps+options+lending+staking+LP+Polymarket. Ultimate stress test	EVM	0x3e8734ec146c981e3ed1f6b582d447dde701d90c
Options trader $1.1M — Derive options $889k + Hedgey + ether.fi	EVM	0x43a9880dA38446a6Cc589BE9070E90A1E5D17ed7
Lending whale $84M — pure Aave V3 USDC supply (clean single-protocol lending test)	EVM	0xd4fa2d31b7968e448877f69a96de69f5de8cd23e
Yield / restaking $3.4M — Pendle LP + Ethena + Swell/Renzo restaking (realistic scale)	EVM	0xac3b4b95a5afb20a055575fdc7fc94b6c64f54a6
Curve / Convex farmer $1.4M — Convex/Curve/Frax/Compound/Lido/GMX, 14 protocols, 8 chains	EVM	0x9c5083dd4838e120dbeac44c052179692aa5dac5
Retail power user $52k — defi+perps(HL/Lighter)+options(Derive)+Polymarket at retail scale	EVM	0xEF7F2e81EA14538858d962df34eB1bFDa83da395
Nine-figure whale $101M — Hyperliquid perps $61M + Aave/Morpho lending + Lyra options + Pendle	EVM	0xbdfa4f4492dd7b7cf211209c4791af8d52bf5c50
HyperEVM whale $34M — HyperEVM-native (Kinetiq, HyperLend, Hyperbeat) + Hyperliquid + ether.fi	EVM	0x7bfee91193d9df2ac0bfe90191d40f23c773c060
Aave + Lido whale $28M — Aave V3 $18M + Lido $10M (concentrated lending + staking)	EVM	0x33eecc48943aaeabb5328a25ff28eb85f67945c2
LST + lending mix $18M — Sky + Aave V3 + Lido + ether.fi + Kelp (liquid staking + lending)	EVM	0x41bc7d0687e6cea57fa26da78379dfdc5627c56d
Restaking whale $11M — ether.fi + Karak + Puffer + Swell + EigenLayer (LRT / restaking)	EVM	0x5c9e30def85334e587cf36eb07bdd6a72bf1452d
Solana DeFi whale $22.3M — Kamino lending $13.5M	SOL	4yhXa4iERFGma3T1HMMjH8nJ8EdFqbahCV5Yomm8Z3do
Solana all-rounder $2.9M — Jupiter Lend + Kamino + Drift + Jito, 31 tokens	SOL	C6Xi6z71oVspEHF4ZYMBckmUPTJpZTvWnTXbYhY1a6Kw
Solana leveraged loop $195k — Kamino leveraged loop, health rate 0.09 (borrow/health decoding test)	SOL	8VRaHB4vZ4R2bZBk9JKRUXQHSaw3SjoAQTSWjWtFFsMx
Solana Jupiter Perps ~$24k — near-pure Jupiter Perps position (perp collateral vs mark-to-market PnL test)	SOL	8idghy9hzgLBkiRF9ssJYq9NJBTy9FxaaRnA27WH45xk
Solana multi-protocol ~$84k — Drift + Jupiter Perps + Marginfi + Meteora + native stake (breadth test across 5+ protocols)	SOL	AYcun6jaNoFAxaNjiyf1vyaWoFCxQVnoRnKQXHzHcjHT
Solana Jupiter degen ~$40k — Jupiter Perps + Jupiter offerbook + JUP DAO + Kamino + Meteora DLMM + Jupiter Lend + Pyth (max-protocol Solana wallet)	SOL	DaBBujR23Jy9apH42DtZ2BaF3JrCNh9tu5bzEN58TQE

Addresses are public on-chain wallets selected to stress distinct capabilities; they are not affiliated with Octav or any provider. Captured in waves: the original EVM wallets 2026-07-02, the Solana wallets 2026-07-13, and five larger EVM wallets 2026-07-13.

Reproduce · Try it · About

Run it yourself

Try the live app

Paste any EVM or Solana address at benchmark.octav.fi and see all nine APIs diffed in real time.

Read the harness

The capture harness, normaliser and this report generator are open at github.com/Octav-Labs/portfolio-api-comparator.

Reproduce the numbers

Every figure is derived from a cached snapshot — re-run capture.mjs on the same wallets to regenerate them.

Published by Octav. Octav is one of the nine APIs measured; the benchmark, rubric and code are open so the comparison can be checked and challenged. Provider names and logos are trademarks of their respective owners. Figures reflect a single snapshot captured 2026-07-13 and each provider's published pricing at that date; treat estimated costs as directional. This document is informational, not financial or procurement advice.

· The Crypto Portfolio API Benchmark · 2026-07-13