# Octav Blog — Full Text > Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. This file contains the complete text of all 44 published articles. Generated 2026-08-19. --- # EVM Portfolio API: A Complete Guide > Reading an EVM wallet means every chain it has touched, not just Ethereum — plus the receipt tokens, NFT positions and proxies that break naive decoding. - **URL:** https://octav.fi/blog/evm-portfolio-api-guide - **Published:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Chains - **Tags:** api, developers, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- "EVM support" sounds like one feature. It is not — it is the same integration problem repeated on every chain a wallet has ever touched, and the count is higher than most teams assume. A single portfolio request for `vitalik.eth` returns value on **44 EVM chains**, out of 66 the response enumerates. Ethereum holds 93.2% of it. The other 43 chains hold $77,714 — the part a report either includes or silently loses. ![Bar chart of the non-Ethereum EVM chains holding value for one address: Base $35,469, BNB Chain $25,490, Optimism $8,607, Manta $4,483, and a long tail down to X Layer at $145](./images/figure-evm-chain-tail.png) Ethereum is left off that chart on purpose. At linear scale it flattens everything else to nothing — which is exactly the mistake the chart is arguing against. ## Why EVM is not one problem Solana is one chain with hard-to-decode programs. EVM is the opposite: the decoding is well understood, and the difficulty is that you have to do it everywhere, forever. | | Solana | EVM | | --- | --- | --- | | Chains to index | 1 | Dozens, and rising | | Same protocol, many deployments | Rare | Normal — Aave and Uniswap run on most L2s | | Contract addresses | Stable per program | Different on every chain | | New surface area | New programs | New chains *and* new protocols | The multiplication is the whole story. Supporting Aave is one integration. Supporting Aave *across chains* is one integration re-verified on every chain it deploys to, because the addresses differ and the deployments drift. Here is what that looks like in a real response — the same protocol, one wallet, two chains, five separate positions: | Chain | Protocol | Position | | --- | --- | --- | | Base | Uniswap V3 | DOGE / WETH | | Base | Uniswap V3 | NMB404 / WETH | | Ethereum | Uniswap V3 | DGENV2 / WETH | | Ethereum | Uniswap V3 | BARK / WETH | | Ethereum | Uniswap V3 | MIERDA / WETH | An API that indexes Ethereum and calls it "Uniswap support" returns three of those five. ## What actually sits in an EVM wallet Four position types, only one of which a balance query returns correctly: | Type | What it looks like on-chain | Naive result | | --- | --- | --- | | Spot tokens | ERC-20 balance | Correct | | Lending | Receipt token (`aToken`) + debt token | Debt counted as an asset | | Liquidity | ERC-721 NFT (Uniswap V3) or LP ERC-20 | Missing, or valued at face | | Vaults / staking | Share token whose price drifts from 1:1 | Undervalued | The lending case is the one that inverts meaning rather than nudging a number. A wallet supplying 6,586 WETH against 2,294,767 USDC of borrow holds a net position near $10.3M — but summing the tokens it *holds* adds the debt as a positive and reports something closer to $12.6M. The mechanics are in [Tracking Aave Positions](/tracking-aave-positions). ## The four things that break EVM decoding **Receipt tokens look like ordinary ERC-20s.** `aUSDC`, `cDAI`, `stETH` and thousands of vault shares are transferable tokens with a balance and a symbol. Treat them as spot holdings and you double-count the underlying. **Liquidity is often not a token at all.** A Uniswap V3 position is an NFT whose contents depend on the pool's current tick. There is no balance to read — the amounts have to be derived. See [Valuing Uniswap V3 Positions](/valuing-uniswap-v3-positions). **Proxies hide the implementation.** Most major EVM protocols sit behind upgradeable proxies, so the address you integrated against is not the logic you decoded. Upgrades change response shapes without changing addresses. **The same symbol is not the same asset.** `USDC` on Ethereum, bridged `USDC.e` on an L2 and a third-party bridge wrapper are different assets with different risk. Collapsing them by symbol produces a tidy, wrong total. ## Querying every chain in one request The practical requirement is that chain count stops being your problem. One address in, every chain out: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" ``` Positions come back grouped by protocol, then chain, so per-chain exposure is a read rather than a reconciliation. Batching several addresses into one request is also the main cost lever — the full parameter and credit table is in the [endpoint reference](/crypto-portfolio-api-endpoint-reference). If you would rather not hold a key at all while evaluating, [Authless](/octav-authless-no-api-key) answers the same question for any EVM address with no account. ## How to evaluate an EVM provider Run these against a wallet whose contents you can verify independently. Each one fails a different class of provider: 1. **Query an address with activity on an L2 you rarely think about.** Does the position appear at all? This is chain coverage, and it is where most of the variance lives. 2. **Query a wallet with an open lending borrow.** Is the debt negative in the total, or added to it? 3. **Query a wallet with a Uniswap V3 position.** Is it present, and are both sides of the pair itemised? 4. **Check a vault or staked position.** Is it valued at the share price or at 1:1? 5. **Ask what happens on an unsupported protocol.** "Omitted silently" and "flagged as unsupported" are very different products. Question 1 is the one to weight. Decoding gaps are visible once you look; missing chains are invisible by construction, because nothing in the response says a chain was never checked. Measured results across nine providers, including where competitors beat us, are in [the benchmark](/crypto-portfolio-api-benchmark) — and the mechanism behind the disagreements is in [Why Portfolio APIs Disagree](/why-portfolio-apis-disagree). ## Where to go next | If you want | Go to | | --- | --- | | The general shape, not EVM-specific | [Crypto portfolio API guide](/crypto-portfolio-api-guide) | | The Solana equivalent of this page | [Solana portfolio API guide](/solana-portfolio-api-guide) | | Every endpoint and credit cost | [Endpoint reference](/crypto-portfolio-api-endpoint-reference) | | To evaluate providers properly | [How to choose a crypto portfolio API](/choosing-a-crypto-portfolio-api) | | A working dashboard on this data | [Build a portfolio dashboard](/build-crypto-portfolio-dashboard) | | An AI agent to consume it | [AI agent tools for portfolio data](/ai-agent-tools-crypto-data) | The multi-chain problem in the abstract — why enumeration is the hard part — is covered in [Tracking DeFi Positions Across Multiple Chains](/track-defi-positions-multichain). --- # Build an AI Agent That Alerts You on Your Positions > Install one MCP server and your AI assistant can watch your DeFi positions — liquidation risk, out-of-range liquidity — and tell you. No code required. - **URL:** https://octav.fi/blog/ai-agent-portfolio-alerts - **Published:** 2026-08-07 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** AI Agents - **Tags:** ai-agents, mcp, defi, api - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- You cannot watch your positions around the clock. Your AI assistant can. Two things go wrong while nobody is looking, and neither shows up in your net worth: - **A loan drifts toward liquidation.** Your collateral falls, your health factor slides, and eventually a bot takes the collateral plus a penalty. - **Capital quietly stops earning.** A liquidity position moves outside its range, turns into one side of the pair, and sits there collecting nothing. Its *value* barely changes — so your portfolio total never flinches. The fix is one install and a few sentences of English. You do not write a parser, you do not learn a response format, you do not write any code at all. Claude, Codex, Gemini or Cursor reads your positions directly and does the work. ## The only setup step Octav ships an MCP server. MCP is the standard that lets an AI assistant call a real data source as a tool — install it once and your agent can read any wallet. Grab a key from [data.octav.fi](https://data.octav.fi) first. In Claude Code and Codex, install is one command: ```bash claude mcp add octav -- npx -y octav-api-mcp # Claude Code codex mcp add octav -- npx -y octav-api-mcp # Codex ``` Claude Desktop, Cursor and Gemini CLI take a JSON block instead: ```json { "mcpServers": { "octav": { "command": "npx", "args": ["-y", "octav-api-mcp"], "env": { "OCTAV_API_KEY": "your-api-key-here" } } } } ``` VS Code wants the same fields, but in `.vscode/mcp.json` and under `servers` rather than `mcpServers` — worth knowing, because pasting the block above into VS Code silently does nothing. Per-client install notes are in the [MCP documentation](https://docs.octav.fi/mcp/overview). That is the last configuration in this article — everything below is just talking. ## Ask it what you are holding Start here, because it proves the connection works and shows you what your agent can actually see: ``` What DeFi positions does 0xb5e6ae546f5e8c75f19ed89a1ca032a5cb8669e8 hold? Break it down by protocol and chain. ``` Your agent calls the portfolio tool and gets back positions that are already decoded — a lending position that knows it is a loan, a liquidity position that knows what is in it. There is nothing to parse. If your own wallet comes back missing something you know you hold, stop here and find out why; every alert you build after this depends on the data being complete. ## Ask it about liquidation risk Lending positions carry a health factor. Below 1.0 they can be liquidated — that part is protocol mechanics, covered in [Tracking Aave Positions](/tracking-aave-positions). Everything above it is margin you are choosing. Just ask: ``` Check every lending position in my wallets. For each one, tell me the health factor and how far it is from liquidation. Flag anything below 1.35. ``` Against the wallet above, that position is a long way from trouble, so nothing fires: ## Ask it to find capital that stopped earning This is the one nobody checks, and it is pure upside — it finds money that is already yours and is doing nothing. When a concentrated liquidity position moves out of its range it converts entirely to one asset and stops collecting fees. The mechanics are in [Valuing Uniswap V3 Positions](/valuing-uniswap-v3-positions). You do not need to know any of it to ask: ``` Look at 0xc9c61194682a3a5f56bf9cd5b59ee63028ab6041. Which liquidity positions have gone out of range, how much capital is stuck in them, and what percentage of my LP book is that? ``` On that wallet the answer is immediate — five BIFI/WETH positions, three of them fully one-sided: Thirteen percent of that wallet's liquidity had quietly stopped working. The capital never went anywhere, which is exactly why no dashboard total would have shown it. ## Turn the question into a standing alert So far you have asked once. Now make it repeat — again, by asking: ``` Set this up to run every hour. Check my wallets, and only message me when something changes: a health factor drops below 1.35, or a liquidity position goes out of range. Stay quiet if nothing changed. ``` Your agent writes and schedules that itself. Ask an agent with shell access and it will set up the scheduled job; ask an assistant with built-in scheduled tasks and it will use those. Either way the part you own is the *instruction*, not the implementation. Two details worth saying out loud when you ask, because they are the difference between an alert you act on and one you mute: | Say this | So that | | --- | --- | | "Only message me when something changes" | You are not pinged 24 times a day about a position that is fine | | "Tell me when it recovers too" | You know when to stop worrying | | "Check hourly, not every minute" | Portfolio data is cached for a minute; faster costs more and tells you nothing new | | "Group related alerts into one message" | Three positions breaking at once is one market move, not three emergencies | ## Ask follow-up questions when something fires This is where an agent beats a threshold alert, and it is the reason to do it this way rather than wiring up a dashboard notification. An alert tells you a number crossed a line. Your agent can read the *entire* decoded portfolio and the transaction history, so it can answer the questions that actually decide what you do: ``` My health factor dropped. Did my collateral fall in price, or did something draw more debt? Show me the transactions. ``` ``` Can I fix this with what I already hold? Check my idle stablecoins and anything sitting in out-of-range positions. ``` ``` Three positions alerted at once. Is this one market move or three separate problems? ``` None of those are things a threshold can answer. All of them are things you want answered before you sign anything. One boundary worth knowing: Octav is **read-only** and never asks for a private key. Your agent can tell you exactly what to do and put a number on it. You are still the one who signs. ## Start here 1. Run the install command. One line. 2. Ask it what your wallet holds. If something you own is missing, that is the real problem and it is better to find it now. 3. Ask it to check your loans, then ask it to check for out-of-range liquidity. 4. Ask it to run that hourly and only message you on a change. That is the whole build. If you would rather not run an agent at all, Octav Pro has Automation and Alerts built in — see the [dashboard tour](/octav-pro-dashboard-tour). If you want to write the monitor yourself instead of having an agent do it, the underlying data and endpoints are in the [API reference](/crypto-portfolio-api-endpoint-reference), and the other ways to give an agent this data — CLI, agent skill, pay-per-call — are compared in [AI Agent Tools for Crypto Portfolio Data](/ai-agent-tools-crypto-data). --- # Build a Crypto Portfolio Dashboard: A Complete Guide > Step-by-step guide to building a crypto portfolio dashboard in Next.js with the Octav API: search any wallet, decode tokens and DeFi across 50+ chains. - **URL:** https://octav.fi/blog/build-crypto-portfolio-dashboard - **Published:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** dashboard, tutorial, developers, api - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- You will build a working **crypto portfolio dashboard** in Next.js: type any wallet address, get its net worth, allocation, token holdings and DeFi positions across 50+ chains. The whole thing is one search box and one API call. The finished code is open source — clone it, run it, ship it: **[github.com/Charlie85270/octav-portfolio-dashboard-tuto](https://github.com/Charlie85270/octav-portfolio-dashboard-tuto)**. ![The finished crypto portfolio dashboard showing net worth, allocation by protocol, chain progress bars and a chain filter](./images/dash-full.jpg) This guide walks the build step by step. Every snippet is copy-paste-able and matches the repo. If you just want to run it, skip to [Run it locally](#run-it-locally). ## What you are building A read-only dashboard that turns a wallet address into a full portfolio view: - **Net worth** with a generated wallet avatar - **Allocation by protocol** (donut) and **by chain** (progress bars) - A **chain selector** that filters the whole portfolio to one network - **Token holdings** with logos, balances and USD values - **DeFi positions** grouped by protocol in an accordion It is read-only by design: it never asks for a private key and cannot move funds. It only ever *reads* public on-chain state through an API. ### Why not just query balances yourself? A raw balance query — `balanceOf` on a few token contracts — only sees tokens sitting loose in the wallet. For an active wallet that is often the *minority* of its value. The rest is inside protocols: supplied to Aave, LP'd on Uniswap, staked, or held as a Hyperliquid perp. Those positions are not balances; each protocol stores them differently, and decoding them yourself means integrating each one. The [Octav API](/crypto-portfolio-api-guide) decodes all of it — tokens *and* protocol positions — in a single request, and returns logos and USD values with it. That is what makes a one-file dashboard possible. See [Why portfolio APIs disagree about your net worth](/why-portfolio-apis-disagree) for what "decoded" actually buys you. ## What you need | Requirement | Notes | | --- | --- | | Node.js 18+ | Any recent LTS. | | An Octav API key | Free to create; a call costs one credit, credits from $10. Get one at [data.octav.fi](https://data.octav.fi). | | 20 minutes | The app is small on purpose. | You do **not** need a key to see the UI — the app ships with sample data and falls back to it when no key is set. Add a key when you want to query real wallets. ## Step 1 — Scaffold the app ```bash npx create-next-app@latest portfolio-dashboard --typescript --tailwind --app cd portfolio-dashboard npm install recharts blockies-react-svg ``` `recharts` draws the allocation donut; `blockies-react-svg` generates the wallet avatar from the address. ## Step 2 — Put the API key on the backend The single most important decision in this build: **the API key never touches the browser.** The browser sends an address to *your* server; your server adds the key and calls Octav. ``` browser ──(address)──▶ /api/portfolio ──(Bearer key)──▶ api.octav.fi reads key from env, /v1/portfolio normalizes the payload ``` If you called Octav directly from client-side React, anyone could open the network tab, copy your key, and spend your credits. A server route keeps the key in `process.env`, where the browser can't see it. Create `app/api/portfolio/route.ts`: ```ts import { NextResponse } from "next/server"; import { getPortfolio } from "@/lib/octav"; import mock from "@/lib/mock.json"; // GET /api/portfolio?address=0x... // Runs on the server. The browser sends only an address; the Octav // API key never leaves the backend. export const dynamic = "force-dynamic"; export const maxDuration = 30; export async function GET(request: Request) { const input = new URL(request.url).searchParams.get("address")?.trim(); if (!input) { return NextResponse.json({ error: "No address provided." }, { status: 400 }); } const addresses = input .split(/[\s,]+/) .map((a) => a.trim()) .filter(Boolean) .slice(0, 10); // keep credit spend bounded per request // No key yet? Return sample data so you can see the dashboard before // signing up. Set OCTAV_API_KEY in .env.local to query real wallets. if (!process.env.OCTAV_API_KEY) { return NextResponse.json({ data: { ...mock, address: input } }); } try { const portfolio = await getPortfolio(addresses); return NextResponse.json({ data: portfolio }); } catch (error) { const message = error instanceof Error ? error.message : "Failed to load portfolio."; return NextResponse.json({ error: message }, { status: 502 }); } } ``` Put your key in `.env.local` (never commit it): ``` OCTAV_API_KEY=your-key-here ``` To get a key: sign in at [data.octav.fi](https://data.octav.fi), create an API key, and buy a few credits (from $10 — most calls cost one credit). See the [endpoint reference](/crypto-portfolio-api-endpoint-reference) for what each call costs. ## Step 3 — Fetch and decode the Octav payload This is the heart of the app. `/v1/portfolio` takes **one address per call** and returns a rich, nested payload. Two query flags matter: - `includeImages=true` — returns chain, token and protocol logos, so you don't have to source them. - `waitForSync=true` — returns freshly indexed data instead of a possibly-stale cache. Create `lib/octav.ts`. First, the fetch (server-side, reads the key): ```ts const BASE = process.env.OCTAV_API_BASE || "https://api.octav.fi"; async function fetchOne(address: string) { const key = process.env.OCTAV_API_KEY; if (!key) throw new Error("OCTAV_API_KEY is not set. See .env.example."); const url = `${BASE}/v1/portfolio?addresses=${encodeURIComponent( address, )}&includeImages=true&waitForSync=true`; const res = await fetch(url, { headers: { Authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(28_000), }); if (res.status === 401) throw new Error("Octav rejected the API key (401)."); if (res.status === 402) throw new Error("Out of Octav credits (402)."); if (!res.ok) throw new Error(`Octav error ${res.status}.`); const json = await res.json(); return Array.isArray(json) ? json[0] : (json?.data?.[0] ?? json?.data ?? json); } ``` ### Understanding the response The payload has three parts you care about: | Field | What it holds | | --- | --- | | `networth` | Total USD value of the wallet. | | `chains` | A map of every chain the wallet touches, with per-chain value and logo. | | `assetByProtocols` | A map keyed by protocol. The special `wallet` key holds loose tokens; every other key is a DeFi protocol with its positions. | That `wallet`-vs-everything-else split is the key insight. Loose tokens live under `assetByProtocols.wallet`; a lending position lives under `assetByProtocols.aave`. `normalize()` flattens both into a shape the UI can map over: ```ts function normalize(raw, address) { const networthUsd = num(raw.networth); // Allocation by chain const chains = new Map(); for (const [key, c] of Object.entries(raw.chains ?? {})) { const value = num(c.value); if (value > 0) chains.set(key, { key, name: c.name ?? key, valueUsd: value, img: c.imgSmall }); } const tokens = new Map(); const positions = []; const byProtocol = []; for (const [key, proto] of Object.entries(raw.assetByProtocols ?? {})) { byProtocol.push({ key, name: key === "wallet" ? "Wallet" : proto.name ?? key, valueUsd: num(proto.value), img: proto.imgSmall, }); for (const [ck, chain] of Object.entries(proto.chains ?? {})) { for (const cat of values(chain.protocolPositions)) { if (key === "wallet") { // Loose token holdings. for (const a of values(cat.assets)) { if (num(a.value) <= 0) continue; const id = `${a.chainKey ?? ck}:${a.contract ?? a.symbol}`; tokens.set(id, { symbol: a.symbol?.toUpperCase() ?? "?", chainKey: a.chainKey ?? ck, img: a.imgSmall, chainImg: chains.get(a.chainKey ?? ck)?.img, balance: num(a.balance), valueUsd: num(a.value), }); } } else { // A DeFi position (lending, LP, staking, perp…). if (num(cat.totalValue) <= 0) continue; positions.push({ protocol: proto.name ?? key, protocolImg: proto.imgSmall, label: cat.name ?? key, chainKey: ck, chainName: chains.get(ck)?.name ?? ck, chainImg: chains.get(ck)?.img, valueUsd: num(cat.totalValue), }); } } } } return { address, networthUsd, byChain: [...chains.values()].sort(byValue), byProtocol: byProtocol.filter((p) => p.valueUsd > 0).sort(byValue), tokens: [...tokens.values()].sort(byValue).slice(0, 50), positions: positions.sort(byValue), }; } ``` The full file — including the helpers (`num`, `values`, `byValue`) and merging several addresses into one view — is in the repo under `lib/octav.ts`. For a deeper look at how protocol positions are decoded, see [Track DeFi positions across chains](/track-defi-positions-multichain). ## Step 4 — The search box and net worth Now the UI. `app/page.tsx` is a client component: a search box posts the address to your `/api/portfolio` route and stores the result. ```tsx "use client"; import { useState } from "react"; import Blockies from "blockies-react-svg"; export default function Home() { const [address, setAddress] = useState(""); const [portfolio, setPortfolio] = useState(null); const [loading, setLoading] = useState(false); async function load(value) { if (!value.trim()) return; setLoading(true); const res = await fetch(`/api/portfolio?address=${encodeURIComponent(value)}`); const json = await res.json(); setPortfolio(json.data ?? null); setLoading(false); } return (
{ e.preventDefault(); load(address); }}> setAddress(e.target.value)} placeholder="0x… or vitalik.eth or a Solana address" />
{/* …results… */}
); } ``` Once `portfolio` is set, the net worth card pairs the value with a wallet avatar generated straight from the address: ```tsx

{usd(portfolio.networthUsd)}

``` With no key set, searching anything returns the sample portfolio, so the empty state is never really empty: ![The dashboard's clean empty state with a search bar](./images/dash-empty.jpg) ## Step 5 — Charts and the chain filter Two charts read at a glance: an **allocation-by-protocol** donut (Recharts) and **by-chain** progress bars. Both map over the normalized arrays — `byProtocol` and `byChain` — and use the same colour palette so the two views agree. The chain selector is a single scrollable row of logo buttons. Selecting one sets a `chain` state value; the token and position lists filter to it with one line each: ```tsx const [chain, setChain] = useState(null); const tokens = chain ? portfolio.tokens.filter((t) => t.chainKey === chain) : portfolio.tokens; const positions = chain ? portfolio.positions.filter((p) => p.chainKey === chain) : portfolio.positions; ``` That is the whole filter: because every token and position already carries its `chainKey` from `normalize()`, narrowing the view is a client-side filter, not another API call. ![The dashboard filtered, with the tokens list and a DeFi positions accordion open](./images/dash-filter.jpg) ## Step 6 — Tokens and DeFi positions The two lists are deliberately different shapes, because the data is: - **Tokens** are flat rows — logo, symbol, balance, USD value — sorted by value. - **DeFi positions** are grouped by protocol into an accordion. A protocol like Lighter or Hyperliquid may hold several positions; grouping keeps the list readable and lets the reader drill in. The largest protocol opens by default so there is always something to see. Both are plain components that map over `portfolio.tokens` and `portfolio.positions`. The full source is in `components/` in the repo. ## Run it locally ```bash git clone https://github.com/Charlie85270/octav-portfolio-dashboard-tuto.git cd octav-portfolio-dashboard-tuto npm install cp .env.example .env.local # add your key, or leave blank for sample data npm run dev ``` Open [http://localhost:3000](http://localhost:3000) and search a wallet. With no key it shows sample data; add `OCTAV_API_KEY` to `.env.local` and restart to query real addresses. Try `vitalik.eth` first. ## Deploy it Push to GitHub, import the repo into [Vercel](https://vercel.com/new), and set `OCTAV_API_KEY` in the project's environment variables. Because the key lives in a server env var and is only read inside the API route, it stays server-side in production too. That's the whole deploy. ## Where to go next The dashboard is a starting point. Some obvious extensions: - **Historical net worth** — chart value over time from the historical endpoint. - **A live iframe instead of a build** — if you don't want to maintain a frontend at all, [embed the Octav widget](/embed-crypto-portfolio-widget). - **Agent access** — the same data feeds an AI agent; see [AI agent tools for crypto data](/ai-agent-tools-crypto-data). - **Not sure Octav is the right API?** — [How to choose a crypto portfolio API](/choosing-a-crypto-portfolio-api) compares the options on coverage. ## Get the code Everything above is in one repo, MIT-licensed: **[github.com/Charlie85270/octav-portfolio-dashboard-tuto](https://github.com/Charlie85270/octav-portfolio-dashboard-tuto)** Fork it, swap in your key, and you have a crypto portfolio tracker that sees the whole wallet — tokens and DeFi — across every chain, from one API call. --- # Export Crypto Transactions to Any Tax Software > Sync accurate multi-chain transaction history with Octav, then export it to Koinly, CoinTracker, TaxBit and seven other crypto tax and accounting platforms. - **URL:** https://octav.fi/blog/export-crypto-transactions-tax-software - **Published:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Tax & Compliance - **Tags:** tax, accounting, export, transactions - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- At tax time the hard part is not the tax software. It is getting a **complete, accurate transaction history** out of a wallet that has touched a dozen chains and a hundred protocols. Block-explorer exports miss internal transfers, mislabel DeFi, and price nothing. Octav does the hard part. It indexes your full multi-chain history, decodes it, and then **exports it in the exact CSV format your tax or accounting platform expects** — Koinly, CoinTracker, TaxBit and seven more. You reconcile once, in Octav, and import into the tools you already use. Octav sits **in front of** your tax stack: best data in, existing subledger and filing tools unchanged. ## Why on-chain history is the hard part A crypto transaction record is only useful for accounting if it is complete, decoded and priced. On-chain, all three are hard: | Problem | What a raw export gets wrong | | --- | --- | | **Multi-chain** | Each chain is a separate explorer with a separate CSV. Fifty exports, fifty formats. | | **DeFi** | A Uniswap swap, an Aave supply or a staking claim shows as opaque `Contract Interaction`, not income or a disposal. | | **Internal transfers** | Moving between your own wallets looks like a taxable send unless it is netted out. | | **Pricing** | Explorers give you amounts, not USD cost basis at the block timestamp. | Octav indexes **50+ chains and 1.1B+ transactions**, decodes protocol activity into typed events, and attaches USD values at the time of each transaction. For why two tools can report the same wallet differently, see [Why portfolio APIs disagree about your net worth](/why-portfolio-apis-disagree). For the accounting side of getting this right, see [Crypto transaction reconciliation](/crypto-transaction-reconciliation). ## Step 1 — Get your transactions Two ways in, same data: - **The app.** Sync a wallet, open **Transactions**, and load the full history. You can try it with no account on [authless.octav.fi/transactions](https://authless.octav.fi/transactions) — it costs about one credit per 250 transactions. For how the keyless app works, see [Try a portfolio API without an API key](/octav-authless-no-api-key). - **The API.** Pull the same history programmatically from the transactions endpoint and pipe it straight into your own subledger. See the [endpoint reference](/crypto-portfolio-api-endpoint-reference) for parameters and credit costs. Either way you get a decoded, priced, deduplicated ledger — the thing your accountant actually needs. ## Step 2 — Export to your tax or accounting platform One click. Choose a format, and Octav writes a CSV that matches that platform's import schema exactly — right columns, right order, right headers. The schemas differ (CoinTracker takes 8 columns, Crypto Tax Calculator takes 15), which is the whole reason a generic export fails and a per-platform one just imports. ![Octav's export dialog listing ten tax and accounting platform formats](./images/tax-export-formats.jpg) There is also an **Expand multi-asset transactions** option — one row per asset — for platforms that want a single asset per line. ### Formats Octav exports Ten supported destinations, with the column count of each format\*: _\*Each platform owns its own import format and can change it at any time. Octav keeps these exports current, but does not guarantee a file will match a platform's current schema exactly — check the import on the platform's side._ The consumer crypto-tax tools (Koinly, CoinTracker, CoinLedger, TokenTax, ZenLedger, Accointing, Crypto Tax Calculator, TaxBit) turn the file into a filing. The accounting platforms (Cryptio, Tres Finance) treat it as a subledger feed for the books. Octav produces the format each one imports cleanly. ## Which format should I pick? Pick the one **you or your accountant already use** — that is the point. Octav is not asking you to switch tax tools; it is making sure whichever you have gets correct on-chain data. | If you… | Export to | | --- | --- | | File your own crypto taxes | Koinly, CoinTracker, CoinLedger, TokenTax, ZenLedger, Crypto Tax Calculator | | Work with a US tax provider | TaxBit, TokenTax | | Keep the books / run a subledger | Cryptio, Tres Finance | | Migrated off Accointing | Any of the above — the source data is the same | ## App or API? - **Use the app** for a one-off or year-end export: sync, load, download, import. - **Use the API** to automate it — a scheduled pull into your subledger, or a monthly close that never touches a manual CSV. For agent and pipeline patterns, see [AI agent tools for crypto data](/ai-agent-tools-crypto-data). Either path, the value is the same: Octav owns the accuracy and coverage problem, and hands your existing tax and accounting stack a clean file it knows how to read. --- # The Most Complete Crypto Portfolio Dashboard > Octav Pro is the most complete crypto portfolio dashboard: customizable widget boards over benchmark-best data across DeFi, options, perps and Solana. - **URL:** https://octav.fi/blog/octav-pro-dashboard-tour - **Published:** 2026-07-26 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Portfolio Management - **Tags:** octav-pro, dashboard, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- [Octav Pro](https://pro.octav.fi) is the most complete crypto portfolio dashboard available — because it is the application layer over the same data engine that **tops our [nine-provider benchmark](/crypto-portfolio-api-benchmark) on coverage and DeFi decoding**, and the only one that also decodes options, perps and Solana DeFi. Best-in-class data underneath, a fully customizable widget dashboard on top, free to start. Two things make a dashboard "complete": the data has to be right, and the view has to be yours. Most trackers give you a fixed layout over shallow data. Octav gives you an accurate, decoded portfolio **and** a board you build widget by widget. ![The Octav Pro main board: net worth, protocol vs wallet split, performance chart, P&L calendar and portfolio treemap on one screen](./images/octav-pro-main-board.jpg) That is one address — net worth $50K, **88.7% of it inside protocols**, with a live performance chart, a daily P&L calendar and a portfolio treemap, all on one board. The wallet-versus-protocol split is the number to read first: for an active portfolio, protocol positions routinely dwarf loose tokens, and that is exactly the value [token-only trackers miss](/why-portfolio-apis-disagree). ## Getting in Sign-in is a magic link — enter an email, click the link, no password. The account is **read-only and never asks for a private key**: Octav operates on public chain data only, and the platform is SOC 2 Type 1 and Type 2 compliant. For a fund evaluating vendors, that combination — no key custody, no signing authority, audited controls — is usually security's first question. Details at [trust.octav.fi](https://trust.octav.fi). ## Search, address book and bundles Search any **address, ENS name, or bundle** from the top bar. The Address Book stores the wallets you track with labels that mean something to your team rather than hex strings, and **bundles** group several addresses into one combined portfolio — a fund, a treasury, a household. | Supports | Example | | --- | --- | | EVM addresses | `0x…` | | Solana addresses | base58 | | ENS names | `vitalik.eth` | | Bundles | many addresses, one portfolio | Labelling is not cosmetic: knowing which addresses you control is what stops internal transfers being booked as disposals during [reconciliation](/crypto-transaction-reconciliation) — the single largest source of false taxable events in crypto accounting. ## Boards: your dashboard, not a template This is where Octav pulls away from every fixed-layout tracker. A **board** is a canvas of widgets, and you can have as many as you need. Out of the box there are ready-made boards — Main Board, Classic Board, Snapshots, Positions over Time, Token Overview, an AI board — and you can build your own from scratch. From **Manage my boards** you can: - **Create a new board** — a blank canvas to lay out exactly the widgets you want. - **Add widgets** from the explorer and **move, resize or remove** them in edit mode. - **Rename, duplicate or reset** a board, or delete it. Duplicate a board to spin a variant for a different audience — one for daily monitoring, one an investor sees — without rebuilding it. ## The widget explorer Every widget lives in the **Widget Explorer**: a searchable catalog you browse by category — Overview, Chains, Protocols, Wallet, Chain Filters — and drop onto any board. ![The Octav widget explorer: a catalog of portfolio widgets by category, free and premium](./images/octav-widget-explorer.jpg) The catalog runs from **24 widgets on the free tier to 39 on Pro**, and includes: | Widget | What it answers | | --- | --- | | Portfolio Summary | Net worth, and the wallet-versus-protocol split | | Performance chart | Value over time — 1D, 1W, 1M, 3M, 6M, YTD, 1Y | | Wallet Token chart | Top holdings as a donut | | Chains / Protocols / Tokens radar | Distribution across networks, protocols, tokens | | Token & Stablecoin overview | Holdings and stablecoin exposure in depth | | Horizontal chain selector | Filter the whole board to one network | | P&L calendar | Daily profit and loss across a month | | Portfolio treemap | Every holding sized by value | Some widgets are free; premium widgets carry a price and a license, so you only pay for the views you actually put on a board. ## Create your own widget Widgets in the explorer carry an **author** — because you are not limited to the ones Octav ships. Build your own widget over the same portfolio data, save it to your boards, and it lives in the explorer like any other. It is the difference between a dashboard you configure and a dashboard you can genuinely extend. Widgets can also be **embedded** outside the app — see [embed a live portfolio widget](/embed-crypto-portfolio-widget). ## Every position, decoded, across every chain The Classic Board is the one to open when you want the full holdings breakdown: portfolio summary and token allocation up top, then every position grouped by protocol, with a per-chain filter across every network the wallet touches. ![The Octav Pro classic board: decoded protocol positions across five chains — Aerodrome, Nest, Rysk and more](./images/octav-pro-classic-board.jpg) Aerodrome, Nest, Rysk, LAGOON — each protocol position resolved individually and priced, not folded into one opaque balance. This is what a benchmark coverage score of 100 looks like in a product, and it is the same decoded data the [API](/crypto-portfolio-api-endpoint-reference) returns. For the sectors most tools miss entirely, see [tracking DeFi positions across chains](/track-defi-positions-multichain), [Hyperliquid perps](/hyperliquid-perps-portfolio-tracking) and [Derive options](/derive-options-portfolio-tracking). ## Transactions A decoded, labelled transaction history, filterable by chain, protocol, type and date range. On Pro, transactions can be **tagged and labelled**, which is what turns raw activity into something an accountant can reconcile from. ## Reports and exports The output of the platform lands in the format the recipient wants — an auditor is not going to log into your dashboard: - **PDF and CSV reports**, plus an asset-variation report and the P&L calendar. - **Tax exports** in the exact schema of ten tax and accounting platforms — Koinly, CoinTracker, TaxBit and more. See [export crypto transactions to any tax software](/export-crypto-transactions-tax-software). ## Beyond the board The sidebar carries the rest of the platform: **Automation** and **Alerts** for scheduled reports and threshold notifications, **Snapshots** for reproducible point-in-time history (which cannot be backfilled — see [daily snapshots](/daily-crypto-portfolio-snapshots)), **Public Treasury** pages for [transparent, access-free NAV](/defi-treasury-transparency-dashboards), and direct **API** access to everything the app shows. ## Plans | Plan | Price | Widgets | Adds | | --- | --- | --- | --- | | Free | $0 | 24 | Customizable boards, up to 5 bundles, 10 addresses per bundle | | Lite | $149/yr per address | 26 | Daily snapshots, historical timeline, analytics widgets | | Pro | $499/yr per address | 39 | Transaction tagging, PDF/CSV reports, P&L calendar | | Enterprise | Custom | 39 | SLA, dedicated support, custom limits and development | Pricing is **per address**, which is the thing to model first — a fund with forty wallets is making a different decision than an individual with three. ## Why it is the most complete dashboard Two reasons, and they compound: 1. **The data is the most complete measured.** Octav ties the top [benchmark](/crypto-portfolio-api-benchmark) scores on coverage and DeFi decoding and is the only provider that also decodes options, perps and Solana DeFi. A dashboard is only as good as the data under it. 2. **The dashboard is genuinely yours.** Unlimited custom boards, a widget catalog you extend with your own widgets, per-chain filtering, bundles — not a fixed template. Start free on any wallet at [pro.octav.fi](https://pro.octav.fi/). For how the app and the API fit a fund's workflow, see [crypto portfolio management for funds](/crypto-portfolio-management-funds), and [the full toolset](/octav-tools-overview) for everything alongside it. --- # Octav vs Zerion: Which Sees More of Your Wallet > Zerion is fast and cheap but misses half a complex wallet. Octav decodes the full portfolio: DeFi, options, perps and Solana, with top benchmark coverage. - **URL:** https://octav.fi/blog/octav-vs-zerion - **Published:** 2026-07-25 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, api, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Zerion is the fastest and cheapest full-portfolio option in our [nine-provider benchmark](/crypto-portfolio-api-benchmark). It is also the one with the biggest accuracy catch: on the same wallets, it scored **48 on coverage** — it resolves under half of a complex wallet. For a plain spot wallet that is invisible. For anything holding real DeFi, it means the number is wrong. Octav scored **100 on coverage** on the identical wallets, and is the only provider tested that also decodes **options, perps and Solana DeFi**. When the portfolio has to be right, that gap is the whole story. ## What Zerion is good at Credit where due: Zerion is a polished consumer wallet and a genuinely fast, cheap API — it topped the benchmark on cost (99) and performance (92). If your holdings are spot tokens on major chains, it will serve you and you will never notice its limits. ## The catch: it misses more than half of a complex wallet Coverage measures how much of a wallet a provider actually resolves. Zerion's 48 means that on an active wallet — lending, LP, staking, perps, options, Solana DeFi — more than half of the value can simply be absent from the response. It does not error. It returns a smaller, confident, wrong number. Two accuracy failure modes show up when a tracker leans on a token-list view of a wallet instead of decoding positions: - **Missing positions.** Whole sectors and chains go unresolved. This is what a coverage score of 48 looks like in practice. - **Double-counting receipts.** A DeFi position leaves a receipt or wrapper token in the wallet — an aToken, an LP token, an LST. If a tracker counts that receipt *and* the underlying value it represents, the same money is booked twice. Octav resolves each receipt to its underlying position, so it is counted once, correctly — never as two holdings. Between them, the result is a net-worth figure you cannot trust for reporting, tax or a product, because you cannot tell which lines are missing and which are doubled. ## Octav vs Zerion, by the numbers From the [benchmark scorecard](/crypto-portfolio-api-benchmark): | | Zerion | Octav | | --- | --- | --- | | Coverage | 48 | **100** | | DeFi decoding | 100 | **100** | | Options / perps / Solana DeFi | Partial | **Full** | | Cost efficiency | **99** | 54 | | Performance | **92** | 40 | | Best for | Fast, cheap spot wallets | Accurate decoded portfolios | Zerion wins on cost and speed; Octav wins on the one thing a portfolio has to be — complete and correct. See the full three-way in [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion). ## The same data in the API or the app Everything the Octav API returns is in the app too, free to use at [pro.octav.fi](https://pro.octav.fi/). Search any address and read the full decoded portfolio across every chain it touches. ![The Octav app decoding a wallet across 48 chains and dozens of protocols — the same data the API returns](./images/octav-pro-board.jpg) One wallet, 48 chains, every protocol position resolved individually and counted once — Aave, Yearn, Euler, Uniswap, Hyperliquid. That is the difference between a coverage of 100 and a coverage of 48. ## Which should you pick? - **Zerion** — a fast, cheap consumer wallet for simple, spot-heavy holdings. - **Octav** — when the wallet holds real DeFi, options, perps or Solana and the number has to be right, as an API to build on or a free app to look at. The benchmark harness is open and the weights are published, so you do not have to take our word for coverage 48 versus 100 — [re-run it](/crypto-portfolio-api-benchmark) on your own wallets, or just check one at [pro.octav.fi](https://pro.octav.fi/). --- # Best Crypto Portfolio Trackers in 2026 > Which crypto portfolio tracker fits which job, based on measured coverage data rather than feature lists — including where each one stops reading your wallet. - **URL:** https://octav.fi/blog/best-crypto-portfolio-trackers-2026 - **Published:** 2026-07-24 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** portfolio-tracker, comparison, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Most "best portfolio tracker" lists rank tools by feature checklists. That is the wrong test, because every tracker claims the same features. The question that actually separates them is how much of your wallet each one can see. We measured that. Nine portfolio data providers, seventeen real wallets, one day — the full method and scorecard is in [the crypto portfolio API benchmark](/crypto-portfolio-api-benchmark). If you just want to start tracking a wallet for free, skip to [the crypto portfolio tracker guide](/crypto-portfolio-tracker). > **Disclosure:** Octav builds one of the tools below and ran the benchmark. The > harness is open and the weights are published: DeBank edges the blended score > on cost and speed, but nothing on the list resolves more of a wallet, more > accurately, across more chains and sectors than Octav. ## First, decide which job you are hiring for "Portfolio tracker" covers four genuinely different products: | Job | What you need | Not what you need | | --- | --- | --- | | Watch my own wallets | A consumer app with a good UI | An API | | Report NAV to investors | Reproducible history, audit trail | A pretty dashboard | | Build a product on the data | An API with predictable shapes | A UI at all | | File taxes | Cost basis and transaction labelling | Live position depth | Picking a tool from the wrong category is the most common mistake. A tax tool will not give you daily NAV; a portfolio API will not file your return. ## Measured coverage, by provider From the benchmark scorecard — coverage is how much of a wallet each provider actually resolved: | Provider | Coverage | DeFi decoding | Overall | | --- | --- | --- | --- | | DeBank | 100 | 100 | **85** | | Octav | 100 | 100 | **82** | | Zerion | 48 | 100 | **79** | | Mobula | 40 | 100 | **75** | | TopLedger | 70 | 100 | **67** | | Zapper | 3 | 100 | **57** | | Nansen | 67 | 100 | **56** | | Dune | 39 | 0 | **50** | | GoldRush | 7 | 0 | **42** | A coverage score is not a quality judgement — Dune and GoldRush are excellent at what they do, which is raw and token-level data rather than decoded portfolios. They score 0 on DeFi decoding because they do not attempt it. ## Recommendations by job **The most complete, accurate picture — any chain, any sector.** Octav. It ties the benchmark's top scores on coverage and DeFi decoding, matches DeBank's EVM depth while covering more protocols on top of it — options, perps, Derive — and is the only tool measured that also resolves Solana DeFi. If your wallet is more than spot tokens on a couple of chains, it is the one that gets the number right. **Watching your own wallets.** For a simple, spot-heavy wallet on major chains, Zerion is a polished consumer app — fastest and cheapest in the benchmark. Deep in EVM DeFi and nothing else, DeBank is strong on its home turf. Both trade away coverage the moment your wallet reaches into Solana, options or perps, where Octav keeps resolving. **Fund reporting and NAV.** You need reproducible point-in-time history, not just a live view. That means [daily snapshots](/daily-crypto-portfolio-snapshots) and a full audit trail — see [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting). Coverage matters most here because a missing sector silently corrupts the number. **Building on the data.** Compare on developer experience and response shape, not on the marketing site. Our [endpoint reference](/crypto-portfolio-api-endpoint-reference) and [how to choose a portfolio API](/choosing-a-crypto-portfolio-api) cover what to evaluate. **Solana-heavy portfolios.** Octav is the best multi-chain choice for Solana: it decodes Solana DeFi positions most providers miss entirely, without making you give up EVM. Coverage elsewhere is dramatically uneven — several providers have no Solana support at all, and TopLedger is Solana-only (chain breadth 9), so it cannot follow the same wallet onto Ethereum. See [the Solana portfolio API guide](/solana-portfolio-api-guide). **Tax.** Neither we nor most providers on this list are tax tools. Koinly and CoinTracker are the established names for filing; a portfolio API feeds them rather than replacing them. ## The test to run yourself Do not take any list's word for it, including this one. Take a wallet you genuinely understand and query each candidate: 1. Does the total match what you know you hold? 2. Are lending, LP and staking positions present, or just tokens? 3. If you hold perps or options, do they appear? 4. Does adding a Solana address change the total? 5. Can you retrieve the portfolio as of a past date? Question 1 sounds trivial and is the whole test. The failure mode across this category is not an error message — it is a plausible number that happens to be missing a sector, which is the subject of [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). --- # Octav vs CoinLedger: Live Portfolio vs Tax Tool > CoinLedger is crypto tax software; its portfolio tracker is a filing by-product. Octav is the live, decoded multi-chain portfolio data that feeds tools like it. - **URL:** https://octav.fi/blog/octav-vs-coinledger - **Published:** 2026-07-24 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, portfolio-tracker, tax - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- CoinLedger markets a "portfolio tracker," but it is a **crypto tax product** first — its tracking is a by-product of cost-basis accounting for filing. Octav is a **live, decoded portfolio** across every chain and protocol. They are not really competitors: Octav is the accurate data source, and it [exports straight into CoinLedger's format](/export-crypto-transactions-tax-software) when it is time to file. If you are choosing what to *see your portfolio in*, that distinction decides it. ## A tax tool is not a live portfolio API Tax software is built to reconstruct historical cost basis from transactions and produce a filing. It is not built to decode, in real time, what a wallet holds right now across dozens of protocols — lending, LP, staking, vaults, perps and options — and value each position at the current price. Those are different jobs with different engines. That is why a tax tool's "tracker" tends to read on-chain DeFi shallowly. It does not need deep live decoding to do taxes; Octav's entire product is deep live decoding. | | CoinLedger | Octav | | --- | --- | --- | | Primary job | Crypto tax filing (cost basis) | Live decoded portfolio (API + app) | | Real-time DeFi decoding | Shallow | Full — lending, LP, staking, vaults | | Options / perps / Solana DeFi | No | Fully decoded | | Benchmarked coverage | Not measured | 100 coverage, 100 DeFi decoding | | Relationship | Consumes Octav's export | Feeds the tax tool | ## The same data in the API or the app Everything the Octav API returns is in the app too, free to use at [pro.octav.fi](https://pro.octav.fi/). Search any address for the full decoded portfolio across every chain it touches. ![The Octav app decoding a wallet across 48 chains and dozens of protocols — the same data the API returns](./images/octav-pro-board.jpg) That is a live portfolio — 48 chains, Aave, Yearn, Euler, Uniswap and Hyperliquid positions decoded individually. A tax product shows you last year's disposals; Octav shows you what the wallet holds now, and it is the only tool in our [benchmark](/crypto-portfolio-api-benchmark) that also decodes options, perps and Solana DeFi. ## Use both, in the right order The clean workflow is Octav for the data, your tax tool for the filing: 1. Octav decodes and prices the full multi-chain history and live positions. 2. Export it in CoinLedger's exact CSV schema — or Koinly, TaxBit, and seven others — from [the transactions exporter](/export-crypto-transactions-tax-software). 3. File in the tool you already use. ## Which should you pick? - **CoinLedger** — when your job is filing a crypto tax return. - **Octav** — when you want an accurate live portfolio across DeFi, options, perps and Solana, as an API or a free app — and the clean data that feeds the filing. See it on any wallet at [pro.octav.fi](https://pro.octav.fi/), or read the [benchmark](/crypto-portfolio-api-benchmark). --- # Crypto Portfolio Tracker: Track Any Wallet Free > Track any wallet's full crypto portfolio free — tokens and DeFi, options, perps and Solana decoded across 50+ chains, with no account and no private keys. - **URL:** https://octav.fi/blog/crypto-portfolio-tracker - **Published:** 2026-07-23 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Portfolio Management - **Tags:** portfolio-tracking, dashboard, octav-pro - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A crypto portfolio tracker shows everything one or more wallets hold, priced, in one place. The catch is that most only see **tokens sitting in the wallet** — and for an active wallet, the majority of value lives inside DeFi protocols, where a plain tracker is blind. Octav is the free tracker that sees the rest. Search any address and it decodes the full portfolio — tokens **and** lending, LP, staking, perps, options and Solana DeFi — across 50+ chains. No account, no private keys. Track any wallet now at [pro.octav.fi](https://pro.octav.fi/). ![Tracking a full crypto portfolio in Octav: net worth, performance, P&L and every holding on one board](./images/octav-pro-main-board.jpg) ## What is a crypto portfolio tracker? It is a tool that turns a wallet address into a readable portfolio: total net worth, what you hold, what each position is worth, and how it changes over time — without you copying balances between chains and protocols by hand. A good one does four things a spreadsheet cannot: - **Aggregates** every wallet and chain into one net-worth figure. - **Decodes** DeFi positions into real values, not opaque receipt tokens. - **Prices** everything at the current market value. - **Updates** as the chain does. ## What makes a good crypto portfolio tracker? Coverage is the whole game. A tracker that misses a sector does not warn you — it just shows a smaller, confident, wrong number. | Look for | Why it matters | | --- | --- | | Multi-chain in one view | Your wallet is not on one chain; your tracker should not be either | | DeFi decoding | Lending, LP, staking, vaults, perps and options are where the value is | | Solana **and** EVM | Solana DeFi is the most commonly missed sector | | Accurate pricing | Positions valued from the underlying, not a thin receipt-token market | | Read-only, no keys | A tracker should never be able to move your funds | | Free to start | You should be able to check a wallet before paying | ## Why most trackers show the wrong number On a plain wallet of spot tokens, every tracker agrees. The gaps open the moment a wallet touches DeFi: a position leaves a receipt token behind, and a tracker that lists the token instead of decoding the position either misses the value or double-counts it. In an [open benchmark of nine providers](/crypto-portfolio-api-benchmark), full-portfolio decoding moved reported net worth by **10× to 600×** on the same wallets. See [why portfolio trackers disagree about your net worth](/why-portfolio-apis-disagree). ## Track your whole portfolio with Octav, free Octav is the application over a data engine that **tied the top benchmark scores on coverage and DeFi decoding** and is the only one that also decodes options, perps and Solana DeFi. As a tracker, that means: - **Search any wallet** — an `0x…` address, a Solana address, or an ENS name like `vitalik.eth`. - **See the full portfolio** — net worth, allocation, every token and every decoded protocol position across 50+ chains. - **Bundle wallets** — group several addresses into one combined portfolio. - **Build your view** — a customizable widget dashboard, charts, P&L calendar and a portfolio treemap. See [the full dashboard tour](/octav-pro-dashboard-tour). ![Octav decoding protocol positions across chains — Aerodrome, Nest, Rysk and more](./images/octav-pro-classic-board.jpg) ## Is it free, and is it safe? Yes to both. - **Free to start.** Track any wallet on the free tier, with paid plans for history, analytics and reporting. - **Read-only.** Octav never asks for a private key and cannot move funds — it reads public on-chain data only. - **Audited.** The platform is SOC 2 Type 1 and Type 2 compliant. Sign-in is a magic link — an email, one click, no password. ## Track DeFi, not just tokens This is the difference between a tracker that is right and one that is close. A token-only view of an active wallet can miss most of its value. Octav decodes it: - [Track DeFi positions across chains](/track-defi-positions-multichain) - [Track Solana DeFi](/solana-defi-portfolio-tracking) - [Track Hyperliquid perps](/hyperliquid-perps-portfolio-tracking) - [Decode Derive options](/derive-options-portfolio-tracking) ## Tracker or API? If you want to *look* at a portfolio, use the app. If you are *building* on the data — a product, a fund's reporting, a tax pipeline — the same decoded data is available as an [API](/crypto-portfolio-api-guide), and it [exports to every major tax platform](/export-crypto-transactions-tax-software). ## Start tracking Open [pro.octav.fi](https://pro.octav.fi/), paste any wallet, and see the whole portfolio — tokens and DeFi, across every chain — for free. For a measured look at how the trackers compare, read [the best crypto portfolio trackers in 2026](/best-crypto-portfolio-trackers-2026). --- # Octav vs Mobula: Chain Breadth vs DeFi Depth > Mobula brings wide chain and market-data coverage at low cost. Octav decodes DeFi, options, perps and Solana with the top benchmark accuracy. Where each fits. - **URL:** https://octav.fi/blog/octav-vs-mobula - **Published:** 2026-07-22 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, api, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Mobula and Octav both offer a portfolio API, and both were measured in our [nine-provider benchmark](/crypto-portfolio-api-benchmark) — which makes the comparison unusually concrete. Mobula's edge is **chain breadth and market data at low cost**. Octav's edge is **decoding accuracy**: reading what a wallet actually holds inside protocols, which is where the value hides. The numbers make the trade-off plain: on the same wallets, Mobula scored **92 on chain breadth but 40 on coverage**, while Octav scored **100 on coverage** and the maximum on DeFi decoding. ## Breadth is not the same as coverage Chain breadth counts how many networks a provider touches. Coverage measures how much of a *wallet* it actually resolves. A provider can index dozens of chains and still miss most of an active wallet's value, because that value lives in lending positions, LP, staking, perps and options — protocol state that a market-data pipeline is not built to decode. | | Mobula | Octav | | --- | --- | --- | | Chain breadth (benchmark) | **92** | 78 | | Coverage (benchmark) | 40 | **100** | | DeFi decoding | Partial | **Full** | | Options / perps / Solana DeFi | Limited | Fully decoded | | Cost | Low | Credit-based, free tier | | Best for | Wide token/market data, cheap | Accurate decoded portfolios | ## The same data in the API or the app Everything the Octav API returns is in the app too, free to use at [pro.octav.fi](https://pro.octav.fi/). Search any address and see the full decoded portfolio across every chain it touches. ![The Octav app decoding a wallet across 48 chains and dozens of protocols — the same data the API returns](./images/octav-pro-board.jpg) Aave, Yearn, Euler, Uniswap and Hyperliquid positions resolved individually — this is what a coverage score of 100 looks like next to a market-data feed's 40. ## Why Octav wins where it counts If your wallets hold nothing but spot tokens on many chains, Mobula's breadth and price are a reasonable fit. The moment a wallet holds real DeFi — which is most active wallets — coverage dominates everything else, and a provider that misses a sector returns a confidently wrong number. See [why portfolio APIs disagree](/why-portfolio-apis-disagree) and [tracking DeFi positions across chains](/track-defi-positions-multichain). Octav's decoding lead is measured, not claimed: the [benchmark](/crypto-portfolio-api-benchmark) harness is open and the weights are published, so you can re-run it on your own addresses. ## Which should you pick? - **Mobula** — for wide, cheap token and market data where deep DeFi decoding is not the point. - **Octav** — when the portfolio has to be accurate: DeFi, options, perps and Solana decoded, as an API or a free app. Try any wallet at [pro.octav.fi](https://pro.octav.fi/), or read the [full benchmark](/crypto-portfolio-api-benchmark). --- # What SOC 2 Type 2 Means for Portfolio Data > Octav is SOC 2 Type 1 and Type 2 compliant. What the difference actually is, what auditors test, and why it matters when a vendor reads your fund's wallets. - **URL:** https://octav.fi/blog/soc2-type-2-certified - **Published:** 2026-07-21 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** NAV Reporting - **Tags:** security, compliance, soc2 - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- **Octav is SOC 2 Type 1 and Type 2 compliant.** Evidence is published at [trust.octav.fi](https://trust.octav.fi). Most vendors that say "SOC 2" mean Type 1. The difference is the whole point of the standard, and it is worth understanding before you accept either as an answer. ## Type 1 vs Type 2 | | SOC 2 Type 1 | SOC 2 Type 2 | | --- | --- | --- | | Question | Are the controls *designed* correctly? | Did the controls *actually operate*? | | Evidence | A snapshot on one date | Continuous evidence over a window | | Window | A point in time | Typically 6–12 months | | Analogy | The fire exits are in the right places | The fire drills were run, logged and passed | Type 1 says a control exists on paper on the day the auditor looked. Type 2 says an independent auditor sampled evidence across months and confirmed the control ran every time it was supposed to. Only one of those tells you what happens on an ordinary Tuesday when nobody is watching. ## What the auditor actually tests SOC 2 is organised around five Trust Services Criteria. Security is mandatory; the others are included based on what the service does. | Criterion | Examples of what gets tested | | --- | --- | | **Security** | Access control, change management, encryption, incident response | | **Availability** | Monitoring, capacity planning, disaster recovery | | **Confidentiality** | Data classification, retention, disposal | | **Processing integrity** | Data is complete, valid and timely | | **Privacy** | Handling of personal information | For a portfolio data provider, **confidentiality** is the criterion that should interest you most, and for a reason specific to this category: your positions are public on-chain, but *the mapping from your fund to a set of addresses is not*. That mapping is exactly what a portfolio vendor holds. See [Security Questions to Ask a Portfolio Vendor](/soc2-security-portfolio-data). ## Why this matters more here than for typical SaaS Two properties compound: **A portfolio provider sees your whole book.** Not one workflow — every position, across every wallet you connect, including [perps](/hyperliquid-perps-portfolio-tracking) and [options](/derive-options-portfolio-tracking) that are otherwise hard to observe from outside. **The data feeds regulated reporting.** If a provider's output flows into [NAV](/what-is-crypto-nav-reporting) or an audit pack, its control environment becomes part of yours. Your auditor will ask about it, and "they have a badge on their website" is not a sufficient answer. ## What SOC 2 does not tell you Being straight about the limits, because a certification is often over-read: - **It is not a guarantee against breach.** It attests that controls were designed and operating, not that nothing can ever go wrong. - **Scope is chosen by the vendor.** A report can legitimately cover a narrow set of systems. Read the scope section, not the summary. - **It says nothing about data quality.** SOC 2 will not tell you whether an API decodes Solana DeFi correctly. That is what [the benchmark](/crypto-portfolio-api-benchmark) is for. - **The window has an end date.** A Type 2 report covers a past period. Ask when the current window closes and when the next report is due. A compliance certificate and a correct portfolio are different assurances. You need both, and they are audited by completely different people. ## How to use this in a vendor review 1. Ask for the **report**, not the badge — under NDA if necessary. 2. Check it is **Type 2**, and read the observation window. 3. Read the **scope**: which systems and which criteria. 4. Read the **exceptions** section. Every real report has some; a vendor that explains theirs is more credible than one that claims none. 5. Confirm the vendor is **read-only and never holds private keys** — for portfolio tracking this matters more than any certification, because it caps the worst case at disclosure rather than loss of funds. Point five is the one people skip. SOC 2 tells you a vendor manages risk well. Read-only access tells you the risk was small to begin with. ## Octav's position - SOC 2 **Type 1 and Type 2** compliant. - **Read-only.** Octav never asks for private keys and cannot move funds. - **Passwordless authentication** via magic link — no password database. - Public evidence at [trust.octav.fi](https://trust.octav.fi). If your security team wants the report or has questions the Trust Center does not answer, ask — that request should never be difficult. --- # Octav vs Nansen: Portfolio Data vs Analytics > Nansen is on-chain analytics: labels and smart-money flow. Octav is decoded portfolio data across DeFi, options, perps and Solana. Which one you actually need. - **URL:** https://octav.fi/blog/octav-vs-nansen - **Published:** 2026-07-19 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, api, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Nansen and Octav get compared because both touch wallets, but they answer different questions. Nansen tells you **who** is doing what on-chain — smart money, wallet labels, flow. Octav tells you **what a wallet actually holds**, decoded and priced across every chain. If you need an accurate portfolio, that second question is the one that matters, and it is Octav's whole job. ## Two different products Nansen is an analytics platform. Its value is labelled intelligence: which wallets are accumulating, where flows are heading, what "smart money" is doing. That is research, not portfolio accounting. Octav is a portfolio data engine — an API and an app on one backend — built to resolve any address into every decoded position: lending, LP, staking, vaults, perps and options, valued at the block timestamp. In our [nine-provider benchmark](/crypto-portfolio-api-benchmark) Octav scored the maximum on coverage and DeFi decoding; Nansen, measured on the same wallets, scored lower on coverage and at the bottom on cost. | | Nansen | Octav | | --- | --- | --- | | Primary job | On-chain analytics, wallet labels | Decoded portfolio data (API + app) | | Portfolio decoding | Secondary to analytics | The core product | | Benchmark coverage | 67 | **100** | | Options / perps / Solana DeFi | Limited | Fully decoded | | Cost | Premium | Credit-based, free tier | | Best for | Research and flow analysis | Getting the portfolio number right | ## The same data in the API or the app Everything the Octav API returns is also in the app, free to use at [pro.octav.fi](https://pro.octav.fi/) — search any address and read the full decoded portfolio, no analytics subscription required. ![The Octav app decoding a wallet across 48 chains and dozens of protocols — the same data the API returns](./images/octav-pro-board.jpg) One wallet, 48 chains, every protocol position resolved individually — Aave, Yearn, Euler, Uniswap, Hyperliquid — priced and categorised. ## Why Octav wins for portfolio accuracy Analytics tools optimise for signal, not for reconciling every position in a wallet to a correct dollar value. When the goal is an accurate portfolio — for reporting, NAV, tax, or a product you are building — coverage and decoding accuracy dominate, and that is measured, not asserted: Octav ties the top [benchmark](/crypto-portfolio-api-benchmark) scores and is the only provider tested that also decodes options, perps and Solana DeFi. See [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion) for the head-to-head against the other API leaders. ## Which should you pick? - **Nansen** — if you want research: smart-money tracking, labels and flow analytics. - **Octav** — if you want the portfolio itself decoded correctly, as an API to build on or a free app to look at. They are complements as often as alternatives. Start with any wallet at [pro.octav.fi](https://pro.octav.fi/), or read the [benchmark](/crypto-portfolio-api-benchmark) for the method behind the numbers. --- # The Crypto Portfolio API Benchmark: 9 Providers > We ran 17 real wallets through 9 crypto portfolio APIs and diffed the results. DeFi decoding moved reported net worth by 10x to 600x. Full scorecard inside. - **URL:** https://octav.fi/blog/crypto-portfolio-api-benchmark - **Published:** 2026-07-16 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** benchmark, api, comparison - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Portfolio APIs all promise the same thing: give us an address, we'll give you the portfolio. In practice they disagree wildly — on the same wallet, on the same day, by as much as 600×. We built [an open benchmark](https://benchmark.octav.fi/report) to find out why. Seventeen real-world wallet archetypes, nine providers, one shared entry point, no hand-typed numbers, captured as a time-aligned snapshot on 13 July 2026. > **Disclosure:** Octav is one of the nine providers measured, and we built the > harness. The methodology is open and the raw data is published so you can > re-run it. We also publish the results where competitors beat us — see the > scorecard below. ## The headline finding: DeFi decoding is the dividing line The single biggest differentiator is not speed, price, or chain count. It is whether an API turns a wallet's on-chain positions — lending, LP, staking, perps, options — into a portfolio, or just lists raw token balances. On the multi-sector whale wallet: | API type | Reported net worth | | --- | --- | | Token-only APIs | $612.6k – $28.60M | | Full-portfolio APIs | $46.27M | That is not a pricing disagreement. On a clean single-protocol Aave wallet, every EVM API reconciles to **within 0.2%** — proof that the large gaps are coverage, not price-feed noise. ## The scorecard Each dimension is scored 0–100 from measured data; the overall is a weighted sum. **Re-weight it for your use case and the order changes** — that is the point of publishing the weights rather than just a ranking. Weights: coverage 25% · DeFi decoding 20% · chain breadth 15% · cost 15% · performance 10% · developer experience 8% · tooling 5% · features 2%. **DeBank edges the blended score, 85 to 82 — and it is bought entirely on cost and response time (79 and 69 against our 54 and 40).** On everything that decides whether a portfolio figure is *right*, Octav is level or ahead: it ties DeBank for the maximum on both coverage and DeFi decoding, then pulls clear on developer experience (90, the highest measured), tooling (82) and features (75, the highest measured). DeBank buys its speed by covering less — it is EVM only, with no Solana DeFi, options or perp decoding. Octav is the only provider here that resolves all three. Reweight the scorecard for a wallet that holds anything beyond EVM spot tokens and Octav is the most complete and most accurate API on the list. ## What each provider is actually for | Provider | Best at | Weak at | | --- | --- | --- | | DeBank | EVM DeFi depth, balanced cost and speed | Tooling (40), no Solana DeFi depth | | Octav | Most complete and accurate: ties the top coverage and decoding scores, and the only API that also decodes options, perps and Solana DeFi | Cost (54) and response time (40) | | Zerion | Fastest and cheapest full portfolio | Coverage (48) on complex wallets | | Mobula | Chain breadth (92) at low cost | Coverage (40) | | TopLedger | Solana-native depth | Chain breadth (9) — Solana only | | Zapper | Cheap DeFi decoding | Coverage (3) | | Nansen | Analytics alongside portfolio | Cost (0) | | Dune | Free token data, wide chains | No DeFi decoding (0) | | GoldRush | Widest raw chain coverage (100) | No DeFi decoding (0), coverage (7) | ## Three sectors almost nobody covers **Options.** Only one of the nine decodes the Derive options book: $1.33M against roughly $401.6k elsewhere. The rest see the collateral and stop. See [Decoding Derive Options in a Crypto Portfolio](/derive-options-portfolio-tracking). **Perps.** Hyperliquid and Lighter positions frequently vanish entirely. See [Tracking Hyperliquid Perps in Your Portfolio](/hyperliquid-perps-portfolio-tracking). **Solana DeFi.** Coverage is uneven and several providers have no Solana support at all. See [Tracking Solana DeFi Positions in a Portfolio API](/solana-defi-portfolio-tracking). ## How to read this if you are choosing an API Ask what your wallets actually hold. If they are spot tokens on major EVM chains, most providers here will serve you and you should optimise for price and latency — Zerion scores 99 on cost and 92 on performance for a reason. If your wallets hold lending positions, LP, staked assets, perps or options, coverage dominates everything else, because an API that misses a sector does not return a slightly wrong number. It returns a confidently wrong one. For the mechanism behind the gaps, read [Why Portfolio APIs Disagree About Your Net Worth](/why-portfolio-apis-disagree). For a direct head-to-head of the top three, see [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion). For consumer-facing tools rather than APIs, see [Best Crypto Portfolio Trackers in 2026](/best-crypto-portfolio-trackers-2026). More head-to-heads: [Octav vs CoinStats](/octav-vs-coinstats), [Octav vs Nansen](/octav-vs-nansen), [Octav vs Mobula](/octav-vs-mobula), [Octav vs CoinLedger](/octav-vs-coinledger) and [Octav vs Zerion](/octav-vs-zerion). For what these providers are being measured *on* — what a [crypto portfolio API](/crypto-portfolio-api-guide) has to return, and how to query one — start with the guide. ## Limitations This is a snapshot of one day. Providers ship changes; coverage moves. The wallet set is seventeen archetypes, not a statistical sample of all wallets. The weights are a judgement call and we have published them so you can disagree with them. Re-run the harness rather than taking our word for it. --- # Octav vs CoinStats: Which Portfolio Data Wins > CoinStats aggregates exchanges and wallets for consumers. Octav decodes DeFi, options, perps and Solana with benchmark-proven accuracy. When each one wins. - **URL:** https://octav.fi/blog/octav-vs-coinstats - **Published:** 2026-07-16 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, portfolio-tracker, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- If you want to see spot balances from your exchanges and wallets in one consumer app, CoinStats does that well. If you need the **on-chain portfolio to be correct** — every lending, LP, staking, perp and options position decoded and priced across every chain — that is a different problem, and it is the one Octav is built to solve. The short version: **CoinStats aggregates, Octav decodes.** Aggregating a list of tokens from connected accounts is not the same as reading what a wallet actually controls on-chain, and the gap is largest exactly where the money is — inside DeFi protocols. ## What CoinStats is built for CoinStats is a consumer portfolio tracker. Its strength is breadth of *connections*: link exchange accounts and wallets and see a combined balance in a polished mobile app. For someone tracking mostly spot holdings across a few CEXs and chains, that is genuinely useful. Where a consumer aggregator runs out of road is depth. A DeFi position is not a token sitting in the wallet — it is a claim held as protocol state, and turning it back into "you own $X of this" means decoding each protocol. That is infrastructure work, not an integration checkbox. ## What Octav is built for Octav is a portfolio **data** engine — an API and an app on the same backend — whose entire job is resolving an address into every decoded position, priced, across chains. In our [nine-provider benchmark](/crypto-portfolio-api-benchmark) it scored the maximum on both coverage and DeFi decoding, and it is the only provider measured that also decodes **options, perps and Solana DeFi**. | | CoinStats | Octav | | --- | --- | --- | | Primary job | Consumer multi-account tracker | Decoded portfolio data (API + app) | | DeFi position decoding | Basic | Full — lending, LP, staking, vaults | | Perps (Hyperliquid, Lighter) | Limited | Decoded | | Options (Derive) | No | Decoded | | Solana DeFi | Token-level | Fully decoded | | Benchmarked accuracy | Not measured | 100 coverage, 100 DeFi decoding | | Free to use | App | App **and** free-tier API | ## The same data in the API or the app Everything the API returns is in the Octav app too — free to use at [pro.octav.fi](https://pro.octav.fi/). Search any address and you get the full decoded portfolio: net worth, allocation, wallet tokens and every protocol position across every chain the wallet touches. ![The Octav app decoding a wallet across 48 chains and dozens of protocols — the same data the API returns](./images/octav-pro-board.jpg) That is one address resolved across 48 chains, with Uniswap, Aave, Yearn, Euler, Sablier and Hyperliquid positions decoded individually — not folded into a single opaque balance. ## Why the difference matters An aggregator that reads DeFi as a token list does not return an error when it misses a position. It returns a confidently wrong number. For an active wallet, the majority of value can live inside protocols — see [why portfolio APIs disagree about net worth](/why-portfolio-apis-disagree) and [tracking DeFi positions across chains](/track-defi-positions-multichain). We do not ask you to take that on faith. The benchmark harness is open and the weights are published, so you can re-run it on your own wallets. ## Which should you pick? - **CoinStats** — if you mainly want a consumer app that ties your exchange accounts and wallets together for a spot overview. - **Octav** — if the on-chain number has to be right: DeFi, perps, options and Solana decoded, available as an API to build on and as a free app to look at. Try it now on any wallet at [pro.octav.fi](https://pro.octav.fi/), or read the [full benchmark](/crypto-portfolio-api-benchmark) to see how the coverage gap was measured. --- # How to Choose a Crypto Portfolio API > A buyer's guide to evaluating crypto portfolio APIs — the tests to run, the questions vendors dislike, and the trade-offs between coverage, cost and latency. - **URL:** https://octav.fi/blog/choosing-a-crypto-portfolio-api - **Published:** 2026-07-07 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** api, developers, comparison - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Every portfolio API demo looks identical: paste an address, see a portfolio. The differences only surface on wallets that are hard, at volumes that cost money, in month three of an integration. Here is how to find them in an afternoon instead. > **Disclosure:** we build one of these. The evaluation below is the one we would > run against ourselves, and the > [benchmark](/crypto-portfolio-api-benchmark) it draws on ranks a competitor > above us overall. ## Step 1: test with a wallet you already understand Not the vendor's demo address — a wallet whose contents you can independently verify. Most providers have a free entry point for exactly this; ours is [Authless](/octav-authless-no-api-key), which needs no key at all. Ideally one holding: spot tokens, a lending position, an LP position, something staked, and — if relevant to you — a perp or an option. Then compare the API's answer against the protocol UIs. The single most useful question is whether the total is right. It sounds trivial. It is the whole test, because the category's failure mode is a plausible number rather than an error. ## Step 2: ask the questions vendors find awkward | Question | What a weak answer sounds like | | --- | --- | | Which sectors do you decode? | "We support all major protocols" | | What happens when a position type is unsupported? | "That doesn't really happen" | | Do you return a price source per asset? | "We use aggregated pricing" | | How do you avoid double-counting receipt tokens? | Silence, or a rewritten question | | What is p95 latency on a complex wallet? | A number for a simple wallet | | What does a busy address cost to index? | A per-call price with no sync cost | The second row matters most. "Omitted silently" and "flagged as unsupported" are very different products, and only one of them is safe to build reporting on. ## Step 3: price the real workload Per-call pricing is misleading on its own. Model your actual pattern: - How many addresses, polled how often? - Does the provider let you batch addresses into one call? (One call with three addresses should cost one unit, not three.) - Is there a one-off indexing cost for busy addresses? Octav charges one credit per 250 transactions on first sync, which is trivial per wallet and material across a fund's whole address book. - What does caching give you? Portfolio data cached for a minute means a dashboard refresh is not a new charge. ## Step 4: weigh the three-way trade-off Coverage, cost and latency pull against each other. Decoding positions across many protocols takes time and infrastructure; providers that skip it are faster and cheaper — but on any wallet with real DeFi, Solana, options or perps they hand you a number that is simply wrong, which no amount of speed makes up for. | Your situation | Optimise for | | --- | --- | | Simple token wallets, high volume | Cost and latency | | Complex DeFi wallets | Coverage, and accept the latency | | User-facing hot path | Latency, with caching in front | | Fund reporting | Coverage and reproducibility | The benchmark makes the trade-off concrete: Zerion scores 99 on cost and 92 on performance with coverage at 48; Octav scores 100 on coverage with cost at 54 and performance at 40. For simple EVM spot tokens, optimise for cost. For anything with real DeFi, Solana, options or perps — which is most active wallets — Octav resolves the most of it, most accurately, and that is what "best" actually means. See [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion). ## Step 5: check what happens after integration Things that only matter later, and are painful to retrofit: - **Historical data.** Can you ask what a portfolio was worth last quarter? Most providers cannot, because [it has to be recorded forward](/daily-crypto-portfolio-snapshots). - **Freshness signals.** Is there a way to know how current the data is? - **Agent access.** If AI agents will consume this, is there [an MCP server or CLI](/ai-agent-tools-crypto-data)? - **Response stability.** Will the shape change under you? ## The short checklist 1. Query a wallet you understand. Is the total right? 2. Add a Solana address. Does the total change correctly? 3. Ask what happens on an unsupported position type. 4. Model the real call volume, including first-sync costs. 5. Ask for a portfolio as of a past date. If a provider passes all five, the rest is implementation detail — and the implementation itself is covered in [Crypto Portfolio API: A Practical Guide](/crypto-portfolio-api-guide). --- # Solana Portfolio API: A Complete Guide > What it takes to read a Solana wallet properly — SPL tokens, staking, lending and perps — and why Solana coverage varies so much between providers. - **URL:** https://octav.fi/blog/solana-portfolio-api-guide - **Published:** 2026-06-30 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Chains - **Tags:** solana, api, developers - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Solana is the chain where portfolio API coverage varies most. On an EVM wallet the major providers broadly agree. On an active Solana wallet they can differ by nearly 3× — $26.04M against ~$9.67M on the same address in [our benchmark](/crypto-portfolio-api-benchmark). This guide covers what a Solana portfolio actually contains and what to require from a provider. ## Why Solana is harder than an EVM chain It is not that Solana is more complex. It is that Solana support is a separate engineering investment rather than a configuration change. | | EVM chains | Solana | | --- | --- | --- | | Address format | `0x…` hex | base58 | | Account model | Contract storage | Program-derived accounts | | Adding a new chain | Largely reuse existing decoders | A distinct integration | | Token standard | ERC-20 | SPL | A provider that supports ten EVM chains got most of that for free after the first. Nothing about that work transfers to Solana, which is why several providers simply do not offer it — and why coverage among those that do ranges from token balances to full position decoding. ## What a Solana wallet holds | Layer | Examples | Balance query sees | | --- | --- | --- | | SPL tokens | USDC, JUP, BONK | Everything | | Native staking | Stake accounts | Nothing — separate accounts | | Liquid staking | jitoSOL, mSOL | A token, priced wrongly | | Lending | Kamino, Jupiter Lend | An obligation, unreadable | | Liquidity | Orca, Raydium | An LP token | | Perps | On-chain perp venues | Nothing | Only the first row is straightforward. Everything below it needs program-specific decoding, covered in depth in [Tracking Solana DeFi Positions](/solana-defi-portfolio-tracking). ## Querying Solana Solana addresses go through the same endpoint as EVM addresses, which matters for anyone running a mixed portfolio: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=,0x" ``` One call, one credit, both ecosystems, one response shape. The alternative — a Solana-specific provider alongside an EVM one — means two integrations, two price sources and a reconciliation problem between them. Solana also has a dedicated endpoint that has no EVM equivalent: ```bash curl -s https://api.octav.fi/v1/airdrop \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=" ``` Full parameters in the [endpoint reference](/crypto-portfolio-api-endpoint-reference). ## Choosing a Solana provider Three questions, in order of how much they matter: **1. Is Solana DeFi decoded, or only SPL balances?** This is the 3× question. Ask specifically about Kamino and Jupiter Lend rather than about "Solana support" in the abstract. **2. Are LSTs valued from the underlying stake?** `jitoSOL` and `mSOL` accrue against SOL, so pricing them as loose tokens understates the position — the same mechanism described in [Valuing stETH and Liquid Staking](/valuing-steth-liquid-staking). **3. Is Solana in the same call as EVM, or a separate product?** This determines whether you build one integration or two. Octav is the most complete answer here: it reads Solana DeFi more fully than any other multi-chain provider measured, and unlike a Solana-only tool it follows the same wallet onto EVM in one call. Two honest caveats: TopLedger is Solana-native and scores 70 on coverage but 9 on chain breadth, so it cannot leave Solana; and Octav's benchmark performance score is 40, because decoding this much takes time. See [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion). ## For AI agents If an agent is analysing Solana wallets, the silent-omission problem is worse than for humans, because the agent has no prior about what should be there. See [A Crypto Portfolio MCP Server for AI Agents](/crypto-portfolio-mcp-server). The EVM side of the same question — where the difficulty is chain count rather than program decoding — is in the [EVM portfolio API guide](/evm-portfolio-api-guide). --- # Crypto Portfolio API Endpoint Reference > Every Octav API endpoint with its parameters, credit cost and response, plus authentication, rate limits and caching behaviour for building on portfolio data. - **URL:** https://octav.fi/blog/crypto-portfolio-api-endpoint-reference - **Published:** 2026-06-25 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** api, developers, reference - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A working reference for the Octav REST API. Base URL `https://api.octav.fi`, Bearer token authentication, credit-based billing. This is the endpoint-by-endpoint reference. For what a [crypto portfolio API](/crypto-portfolio-api-guide) returns and how to query one, start with the guide. ## Authentication and limits | | | | --- | --- | | Auth | `Authorization: Bearer ` — keys from [data.octav.fi](https://data.octav.fi) | | Rate limit | 360 requests/minute per key | | Rate headers | `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset` | | Billing | Credits, roughly $0.020–$0.025 each; most endpoints cost 1 | | Caching | Portfolio 1 minute, transactions 10 minutes | | Addresses | EVM (`0x…`) and Solana (base58), comma-separated in one request | Batching addresses into a single request is the main cost lever: one call with three addresses costs one credit, three calls cost three. ## Portfolio and valuation | Endpoint | Method | Credits | Returns | | --- | --- | --- | --- | | `/v1/portfolio` | GET | 1 | Multi-chain holdings, decoded DeFi positions, net worth | | `/v1/nav` | GET | 1 | A single net asset value figure | | `/v1/wallet` | GET | 1 | Token balances and USD values only | | `/v1/token-overview` | GET | 1 | Token breakdown by protocol — PRO only | | `/v1/portfolio/at-block` | GET | 1 + add-on | Valuation at a specific Ethereum block | | `/v1/historical` | GET | 1 | Portfolio snapshot at a past date | `/v1/portfolio` is the core endpoint and the one that decodes positions. `/v1/wallet` deliberately does not — use it when you only want token balances and want to pay less for them. ## Transactions | Endpoint | Method | Credits | Returns | | --- | --- | --- | --- | | `/v1/transactions` | GET | 1 | Labelled transaction history | | `/v1/sync-transactions` | POST | 1 + 1 per 250 txns | Triggers indexing for an address | `/v1/transactions` filters on `limit`, `offset`, `sort`, `chain`, `type`, `protocol` and `dateRange`, across 53 transaction types. First sync of a busy address has a variable cost, which is worth knowing before you loop over a fund's whole address book. ## Snapshots and history | Endpoint | Method | Credits | Returns | | --- | --- | --- | --- | | `/v1/subscribe-snapshot` | POST | 1200 | Enables daily automatic snapshots | | `/v1/historical` | GET | 1 | Portfolio as of a past date | Snapshots only record forward from the moment you subscribe — see [Daily Crypto Portfolio Snapshots](/daily-crypto-portfolio-snapshots). ## Discovery and account (free) | Endpoint | Credits | Returns | | --- | --- | --- | | `/v1/chains` | Free | Supported blockchains | | `/v1/chains/{chainKey}/protocols` | Free | Protocols on a chain | | `/v1/status` | Free | Sync status and data freshness for an address | | `/v1/credits` | Free | Remaining credit balance | Call `/v1/status` before trusting a portfolio response in a reporting pipeline; it tells you how fresh the underlying data is. ## Specialised | Endpoint | Credits | Notes | | --- | --- | --- | | `/v1/approvals/{chain}` | 1 | Token approvals — security review | | `/v1/contract-protocol` | 5 (refunded on 404) | Resolve a contract to a protocol | | `/v1/airdrop` | 1 | Airdrop eligibility — Solana only | | `/v1/beacon/validators/*` | Add-on | Ethereum validator details and rewards | | `/v1/virtual-users` | 1 | PRO only | | `/v1/virtual-users/portfolio` | 1 per address | PRO only | ## Errors worth handling | Code | Meaning | What to do | | --- | --- | --- | | 401 | Bad or missing key | Check the `Authorization` header | | 402 | Out of credits | Top up at data.octav.fi | | 403 | PRO endpoint | Subscribe, or use a non-PRO equivalent | | 404 | Address not indexed | Above 100k transactions, contact support | | 429 | Rate limited | Honour `Retry-After`, back off exponentially | 402 is the one people forget. An unhandled 402 in a nightly NAV job produces a silent gap in your reporting rather than a loud failure. ## Coverage 33+ decoded DeFi position types across lending, liquidity, staking, vaults, perpetuals and margin, spanning EVM chains, Solana and Hyperliquid. What that covers in practice is measured in [the portfolio API benchmark](/crypto-portfolio-api-benchmark). ## Other ways in The same data is available through an [MCP server](/crypto-portfolio-mcp-server) for AI agents, a [Rust CLI](/octav-cli-rust) and [x402](/x402-pay-per-call-api), and an [embeddable widget](/embed-crypto-portfolio-widget) if you want UI rather than JSON. --- # Octav vs DeBank vs Zerion: Portfolio APIs > A measured head-to-head of the three top-scoring crypto portfolio APIs: DeFi depth, Solana, options, cost and latency, with the numbers behind each. - **URL:** https://octav.fi/blog/octav-vs-debank-vs-zerion - **Published:** 2026-06-21 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** comparison, api, benchmark - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- These three finished at the top of [our nine-provider benchmark](/crypto-portfolio-api-benchmark): DeBank 85, Octav 82, Zerion 79. The blended number is close, but it hides the thing that actually decides whether a portfolio figure is right — how much of a real wallet each one resolves, and how accurately. On that axis Octav is the most complete: it ties DeBank for the top coverage and DeFi-decoding scores, and it is the only one of the three that also decodes options, perps and Solana DeFi. > **Disclosure:** Octav is one of the three. We built the benchmark harness and > publish the methodology, the weights and the results where we lose. ## The short version | | DeBank | Octav | Zerion | | --- | --- | --- | --- | | Overall | **85** | 82 | 79 | | Coverage | **100** | **100** | 48 | | DeFi decoding | **100** | **100** | **100** | | Chain breadth | **80** | 78 | 69 | | Cost efficiency | 79 | 54 | **99** | | Performance | 69 | 40 | **92** | | Developer experience | 78 | **90** | 88 | | Tooling | 40 | 82 | **86** | | Features | 63 | **75** | 50 | Read that as three different bets: - **Octav** — the most complete. Ties the top coverage and decoding scores, and the only one that also resolves options, perps and Solana DeFi in the same call. If a figure has to be right, this is the safe default. - **DeBank** — the EVM specialist. Full EVM DeFi coverage at balanced cost and speed, but EVM only: no Solana DeFi, options or perp decoding. - **Zerion** — the fastest and cheapest. Fine if your wallets are simple; its coverage score of 48 means it resolves under half of a complex one. ## Where the coverage difference shows up Coverage only matters when a wallet holds something unusual. On a plain token wallet all three agree to within a fraction of a percent. The gaps appear by sector: | Sector | DeBank | Octav | Zerion | | --- | --- | --- | --- | | EVM tokens | Full | Full | Full | | EVM lending / LP / staking | Full | Full | Partial | | Perps (Hyperliquid, Lighter) | Partial | Full | Partial | | Options (Derive) | Collateral only | Full | Collateral only | | Solana DeFi | None | Full | Partial | ![Sector coverage matrix for DeBank, Octav and Zerion](./images/figure-sector-matrix.png) The options line is the starkest: on the Derive book, full decoding reports $1.33M where collateral-only reads report about $401.6k. That is not a rounding difference, it is a different answer to "what do I own". ## Where Octav loses Two dimensions, and they are real: **Cost — 54 vs Zerion's 99.** Octav is credit-based at roughly $0.020–$0.025 per credit, with most endpoints costing one credit. Zerion is materially cheaper per call. If you are polling thousands of simple wallets on a loop, that difference compounds fast — as long as those wallets stay simple. Point Zerion at anything with real DeFi and it resolves under half of it (coverage 48), so the saving buys you a wrong number. **Performance — 40 vs Zerion's 92.** Decoding positions across many protocols costs time. If you need sub-second responses in a user-facing hot path, budget for caching or pick a faster provider. Portfolio responses cache for one minute; transactions for ten. We would rather publish that than have you discover it in week two of an integration. ## Where Octav wins **Developer experience — 90, the highest measured.** One call, Bearer-key auth, tokens and every decoded DeFi position returned in a single predictable shape, across 19 endpoints. See the [endpoint reference](/crypto-portfolio-api-endpoint-reference). **Tooling — 82 vs DeBank's 40.** An [MCP server](/crypto-portfolio-mcp-server), a [Rust CLI](/octav-cli-rust) and [x402](/x402-pay-per-call-api), a no-code [widget builder](/embed-crypto-portfolio-widget), daily [snapshots](/daily-crypto-portfolio-snapshots) and public [transparency dashboards](/defi-treasury-transparency-dashboards). **Sector completeness.** Options, perps and Solana DeFi from one integration rather than three providers stitched together. ## Which one should you pick | If you… | Pick | | --- | --- | | Track simple token wallets at high volume | Zerion | | Need EVM DeFi depth with balanced cost and speed | DeBank | | Hold options, perps or Solana DeFi | Octav | | Need one integration covering every sector | Octav | | Optimise purely for latency | Zerion | Re-weight the scorecard and the order shifts on cost and speed — but coverage and accuracy do not move. For any wallet beyond simple EVM spot tokens, Octav resolves the most of it, most accurately, which is why it is the safe default when the number has to be right. We published the weights so you can prove that for your own wallets rather than take our word for it. --- # AI Agent Tools for Crypto Portfolio Data > A survey of how AI agents get on-chain data — MCP servers, agent skills, CLIs and pay-per-call rails — and the failure modes specific to autonomous consumption. - **URL:** https://octav.fi/blog/ai-agent-tools-crypto-data - **Published:** 2026-06-13 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** AI Agents - **Tags:** ai-agents, mcp, tooling - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Giving an AI agent access to crypto data is now a solved integration problem and an unsolved reliability problem. The plumbing is straightforward; the hard part is that agents cannot tell when the data they received was incomplete. ## The four integration rails | Rail | Shape | Best when | | --- | --- | --- | | **MCP server** | Tools exposed to the model | The agent runs in Claude, Codex, Gemini | | **Agent skill** | Structured instructions | You want the agent to learn an API's conventions | | **CLI** | A binary the agent shells out to | Sandboxed agents, shell-native workflows | | **x402** | Pay-per-request over HTTP 402 | Autonomous agents with no provisioned key | These are complements, not competitors. An agent in an IDE wants MCP; an agent in a CI job wants a CLI; an agent you did not provision wants x402. For a step-by-step build on the same data, see [Build a Crypto Portfolio Dashboard](/build-crypto-portfolio-dashboard). Octav ships all four — [MCP server](/crypto-portfolio-mcp-server), [agent skill](https://github.com/Octav-Labs/octav-api-skill), [Rust CLI](/octav-cli-rust) and [x402](/x402-pay-per-call-api) — which is a large part of why the benchmark scored it 82 on tooling against DeBank's 40. ## Three failure modes specific to agents **Silent omission is worse for agents.** A human looking at a portfolio notices their Kamino loan is missing. An agent has no prior — it treats the response as the complete state of the world and reasons confidently from a subset. Given a token-only API, an agent will produce a fluent, well-structured analysis of a portfolio that does not exist. **Loops are expensive.** Agents iterate willingly. A poorly-scoped task can generate thousands of calls. Two defences: batch addresses into a single request rather than iterating, and lean on caching — portfolio responses cache for one minute, transactions for ten. Rate limiting is 360 requests per minute per key. **Stale data reads as current.** An agent asked "what is this portfolio worth" will not think to ask when the data was indexed. Exposing a freshness signal — `/v1/status` returns sync state — lets the agent check rather than assume. ## What makes an API agent-friendly Beyond the transport, a few properties matter disproportionately when the consumer is a model rather than a person: 1. **One predictable response shape** across every position type. Agents handle uniform structures far better than sector-specific special cases. 2. **Explicit units and price sources**, so the agent is not inferring whether a number is tokens or dollars. 3. **Errors that say what to do.** A 402 that says "insufficient credits" is actionable; a bare 500 is not. 4. **Discovery endpoints.** `/v1/chains` and `/v1/chains/{key}/protocols` let an agent establish what is supported before querying, rather than guessing and failing. ## Machine-readable content, not just APIs The same argument applies to documentation and written content. Agents fetching a rendered marketing page pay for layout markup they cannot use. This blog serves a markdown version of every article at `.md` and an index at [/llms.txt](/llms.txt) — the article you are reading is roughly 94% smaller in that form. That is not a courtesy; it is the difference between an article being read in full and being truncated. ## Where this is going The interesting shift is agents that act on portfolio data rather than summarising it — rebalancing, monitoring liquidation risk, reconciling transactions. Each of those raises the cost of incomplete data from "embarrassing" to "expensive", which is why coverage, not convenience, is the thing to evaluate first. See [the portfolio API benchmark](/crypto-portfolio-api-benchmark). The monitoring case is worked through end to end, with polling code and real positions, in [Build an AI Agent That Alerts You on Your Positions](/ai-agent-portfolio-alerts). --- # Crypto Portfolio Management for Funds > The operating stack a digital asset fund needs — position enumeration, valuation, exposure, NAV, reconciliation and reporting — and where each stage breaks. - **URL:** https://octav.fi/blog/crypto-portfolio-management-funds - **Published:** 2026-06-09 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Portfolio Management - **Tags:** portfolio-management, funds, operations - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Managing a digital asset portfolio at fund scale is five distinct problems that get treated as one. Most operational pain comes from solving them in the wrong order — usually by starting at reporting and working backwards. ## The stack | Stage | Question it answers | Fails when | | --- | --- | --- | | 1. Enumeration | What do we hold? | A sector is silently missing | | 2. Valuation | What is it worth? | Prices come from inconsistent sources | | 3. Exposure | What are we exposed to? | Value is confused with exposure | | 4. NAV | What is the fund worth? | The number cannot be reproduced | | 5. Reconciliation | Why did it change? | Transactions are unlabelled | Each stage depends entirely on the one above it. A perfect NAV process built on incomplete enumeration produces a precise wrong answer, and no downstream control will catch it — the missing positions never entered the pipeline. ## Stage 1 is where funds actually lose Enumeration sounds like the easy part and is the part that breaks. A fund's balance sheet is spread across wallets, exchanges, custodians, lending markets, liquidity pools, staking, vesting contracts and derivatives venues — across however many chains the strategy touches. The measured consequence, from [our nine-provider benchmark](/crypto-portfolio-api-benchmark): token-only data sources reported between $612.6k and $28.60M for a wallet worth $46.27M. That is a 10× to 600× range depending on how much the source could decode. If stage 1 is wrong, stages 2–5 are theatre. ## Stage 3: value is not exposure For spot holdings the two are identical, which is why the distinction gets lost. They diverge as soon as leverage appears. | Position | Value | Exposure | | --- | --- | --- | | $1M spot ETH | $1M | $1M ETH | | Aave: $1M supplied, $400k borrowed | $600k net | $1M ETH long, $400k USDC short | | $50k perp margin, 10× | $50k | $500k notional | A risk limit written against value and a risk limit written against exposure are different limits. See [Tracking Aave Positions](/tracking-aave-positions) and [Tracking Hyperliquid Perps](/hyperliquid-perps-portfolio-tracking). ## Stage 4: reproducibility beats accuracy An auditor's question is rarely "is this number right today". It is "show me how you arrived at it, and show me the same number again in six months". That requires point-in-time records rather than recomputation, because protocols get upgraded, deprecated and shut down — see [Daily Crypto Portfolio Snapshots](/daily-crypto-portfolio-snapshots) and [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting). ## Stage 5: label once, not every quarter Reconciliation is mostly a classification problem, and most of it is mechanical. The work is making the machine handle the repetitive majority and routing only genuine ambiguity to a human — plus knowing your own address book so internal transfers are never booked as disposals. See [Crypto Transaction Reconciliation for Audits](/crypto-transaction-reconciliation). ## Build or buy Teams reliably underestimate stage 1 and overestimate stages 2–5. Valuation, exposure, NAV and reporting are ordinary finance engineering — real work, but bounded, and your team understands your mandate better than a vendor will. Enumeration is unbounded: it scales with protocols × chains × versions, it never stops changing, and being 95% complete is indistinguishable from being 100% complete right up until it is not. Before signing with anyone, run the vendor review: [Security Questions to Ask a Portfolio Vendor](/soc2-security-portfolio-data) and check the certification actually says what you think — [What SOC 2 Type 2 Means](/soc2-type-2-certified). The pragmatic split most funds land on is to buy enumeration and valuation as data, and build the parts that encode their own policy. What to look for is in [How to Choose a Crypto Portfolio API](/choosing-a-crypto-portfolio-api). ## Where to start If you are standing this up now, in this order: 1. Get a complete address inventory. Everything, including dormant wallets. 2. Verify enumeration against wallets you can check by hand. 3. Turn on snapshots before you need history — it cannot be backfilled. 4. Fix one price source and timestamp convention, and write it down. 5. Only then build reporting. --- # Why Portfolio APIs Disagree About Net Worth > Two crypto portfolio APIs can report a 600x difference for the same wallet on the same day. The cause is almost never pricing — it is what they can decode. - **URL:** https://octav.fi/blog/why-portfolio-apis-disagree - **Published:** 2026-06-04 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Benchmarks & Comparisons - **Tags:** benchmark, defi, comparison - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- If two portfolio APIs return different net worth for the same address, the instinct is to blame price feeds. That is almost never the cause. On a clean single-protocol Aave wallet, every EVM API in [our nine-provider benchmark](/crypto-portfolio-api-benchmark) reconciles to **within 0.2%**. Prices are a solved problem. What is not solved is knowing what the wallet holds in the first place. ## A balance query is not a portfolio Ask an RPC node what an address holds and you get a list of token balances. For a wallet that only holds spot tokens, that list *is* the portfolio. For a wallet that has done anything in DeFi, the tokens in it are receipts: | What you hold | What a balance query sees | What it is worth | | --- | --- | --- | | Supplied to Aave | `aUSDC` balance | Principal + accrued interest | | LP on Uniswap | LP token balance | A share of the pool's current composition | | Staked SOL via Jito | `jitoSOL` balance | Staked principal + rewards | | Perp position on Hyperliquid | Nothing in the wallet | Margin + unrealised PnL | | Options on Derive | Collateral token | The value of the options book | The last two are the reason the gaps get extreme. A perp position is not a token at all — it is state inside a protocol. An API that only enumerates tokens cannot see it, and will not tell you it cannot see it. It returns a number that looks complete. ## How large the gap gets From the benchmark, same wallets, same day: | Wallet | Token-only APIs | Full-decoding APIs | | --- | --- | --- | | Multi-sector whale | $612.6k – $28.60M | $46.27M | | Solana DeFi whale | ~$9.67M | $26.04M | | Derive options book | ~$401.6k | $1.33M | | Hyperliquid perp trader | ~$27k | $56k | Across the wallet set the spread between token-only and full-portfolio APIs runs from **10× to 600×**. ## Four failure modes to test for When you evaluate a provider, these are the specific things that break. Test them with a wallet you already know the answer for. **1. Silent omission.** The API returns 200 OK with a partial portfolio and no indication that a sector was skipped. This is the dangerous one — an error you can handle, a confident wrong number you cannot. **2. Receipt tokens priced as tokens.** An LST priced from a thin market rather than from the underlying stake. An LP token priced by its own market rather than by pool composition. **3. Double counting.** The same value reported twice — once as the receipt token and once as the decoded position. Ask your provider whether it ships a price source per asset so you can audit which is which. **4. Chain gaps presented as zero.** A provider without Solana support does not return "unsupported"; it returns a portfolio without the Solana half. ## What to ask a provider - Which sectors do you decode: lending, LP, staking, perps, options? - Which chains have DeFi decoding, not just token balances? - Do you return a price source per asset? - What happens when a position type is unsupported — omitted, or flagged? - How do you avoid double-counting receipt tokens? ## The practical consequence For a fund, this is not an academic problem. A NAV built on an API that misses a sector is wrong in a way no amount of downstream reconciliation will catch, because the missing positions never enter the pipeline. See [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting) for how position enumeration feeds the rest of the process, and [Tracking DeFi Positions Across Multiple Chains](/track-defi-positions-multichain) for why the problem multiplies per chain. --- # A Crypto Portfolio MCP Server for AI Agents > How to give Claude, Codex or Gemini live on-chain portfolio data through an MCP server, and why token-only APIs make agents confidently wrong about wallets. - **URL:** https://octav.fi/blog/crypto-portfolio-mcp-server - **Published:** 2026-05-28 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** AI Agents - **Tags:** mcp, ai-agents, api - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- An AI agent asked to analyse a wallet is only as good as the data it can reach. Give it a token-only API and it will produce a fluent, well-structured, badly wrong answer — because it has no way to know that the lending, staking and perp positions were never in the response. The [Model Context Protocol](https://modelcontextprotocol.io) is how you hand an agent a real data source. Octav ships an MCP server for exactly this. ## What the MCP server exposes Once connected, the agent can call the Octav API directly as tools — portfolio, transactions, NAV, historical snapshots and the rest of the [endpoint surface](/crypto-portfolio-api-endpoint-reference) — without you writing any glue code. | Capability | What the agent can do | | --- | --- | | Portfolio | Resolve an address into decoded positions across chains | | Transactions | Pull labelled transaction history with filters | | NAV | Fetch a single net asset value figure | | Historical | Ask what a portfolio looked like on a past date | | Chains / protocols | Discover what is supported before querying | ## Setup The server is at [github.com/Octav-Labs/octav-api-mcp](https://github.com/Octav-Labs/octav-api-mcp). Add it to your MCP client configuration: ```json { "mcpServers": { "octav": { "command": "npx", "args": ["-y", "octav-api-mcp"], "env": { "OCTAV_API_KEY": "your-key" } } } } ``` Then ask in natural language: ``` What DeFi positions does 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 hold, and what is the total exposure by chain? ``` The agent calls the portfolio tool, receives decoded positions, and reasons over real data instead of guessing. ## Why decoding matters more for agents than for humans A human looking at a dashboard notices when a position is missing — they know they have a Kamino loan and can see it is absent. An agent has no prior. It treats the API response as the complete state of the world. That makes silent omission uniquely dangerous in agent workflows. An API that returns 200 OK with half a portfolio does not produce a visible error; it produces a confident conclusion built on missing data. The mechanics of that failure are covered in [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). ## The rest of the agent toolkit The MCP server is one of four ways to give an agent portfolio access: | Tool | Use it when | | --- | --- | | MCP server | The agent runs in Claude, Codex, Gemini or another MCP client | | [Agent skill](https://github.com/Octav-Labs/octav-api-skill) | You want the agent to learn the API's shape and conventions | | [Rust CLI](/octav-cli-rust) | The agent has shell access and you want terminal-native calls | | [x402 pay-per-call](/x402-pay-per-call-api) | The agent should pay per request without a provisioned key | ## A note on rate limits and cost Agents are enthusiastic. They will happily call an endpoint in a loop. The API allows 360 requests per minute per key and bills in credits at roughly $0.020–$0.025 each, with most endpoints costing one credit. Two practical defences: pass multiple addresses in a single request rather than looping (`?addresses=0x123,0x456`), and rely on the built-in caching — portfolio responses cache for one minute, transactions for ten. If you want hard spend limits per call rather than a shared key, that is what [x402 is for](/octav-cli-rust). --- # What Is NAV Reporting for Crypto Funds? > How digital asset funds calculate Net Asset Value across wallets, chains and DeFi protocols — and why manual spreadsheet NAV breaks at scale. - **URL:** https://octav.fi/blog/what-is-crypto-nav-reporting - **Published:** 2026-05-23 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** NAV Reporting - **Tags:** nav-reporting, fund-accounting, compliance - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Net Asset Value is the single number a fund's investors, auditors and administrators all agree to look at. For a traditional fund it is close to arithmetic. For a digital asset fund holding positions across fifteen chains and forty protocols, arriving at that number is the hard part. ## What NAV means for a digital asset fund NAV is total assets minus total liabilities, divided by units outstanding. The definition does not change because the assets are on-chain. What changes is the difficulty of enumerating the assets in the first place. A crypto fund's balance sheet is spread across: | Position type | Where it lives | Why it is easy to miss | | --- | --- | --- | | Spot holdings | Wallets, exchanges, custodians | Multiple addresses per strategy | | Lending positions | Aave, Morpho, Compound | Principal and accrued interest are separate | | LP positions | Uniswap, Curve, Balancer | Value is a function of pool composition | | Staked assets | Native staking, liquid staking | Rewards accrue continuously | | Vesting or locked | Escrow, veTokens | Illiquid, but still an asset | ## Why spreadsheet NAV breaks Manual NAV works at ten positions. It fails at two hundred, for reasons that compound: - **Pricing is inconsistent.** Two analysts pull a token price from two venues at two timestamps and produce two different NAVs. - **Protocol positions are opaque.** A balance query returns an LP token, not the underlying assets it represents. - **Reconciliation is unbounded.** Every new chain the fund touches multiplies the number of sources someone has to check by hand. ## What an automated NAV process needs Any system that produces an auditable NAV has to do four things: 1. Discover every position the fund holds, without being told where to look. 2. Value each position from a consistent, timestamped price source. 3. Snapshot the result daily, immutably, so prior NAVs can be re-derived. 4. Produce an export an auditor accepts without re-keying it. Points three and four are where most in-house tooling stops. A number you cannot reproduce six months later is not a number an auditor can sign off on. ## Further reading Enumerating positions is the hard half of NAV, and it is its own subject: [Tracking DeFi Positions Across Multiple Chains](/track-defi-positions-multichain) covers why lending, LP and staking positions resist a simple balance query. If you would rather pull the underlying data yourself, see the [crypto portfolio API](/crypto-portfolio-api-guide) guide. Once the NAV exists, the movements behind it still have to be booked and evidenced: [Crypto Transaction Reconciliation for Audits](/crypto-transaction-reconciliation). For how NAV fits the wider operating stack, see [Crypto Portfolio Management for Funds](/crypto-portfolio-management-funds). --- # Tracking Solana DeFi Positions in a Portfolio > Solana DeFi is the least-covered sector in portfolio APIs. How Kamino, Jupiter, Jito and LST positions break token-only portfolio tracking. - **URL:** https://octav.fi/blog/solana-defi-portfolio-tracking - **Published:** 2026-05-19 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** DeFi Tracking - **Tags:** solana, defi, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Solana is where portfolio APIs diverge most. In [our nine-provider benchmark](/crypto-portfolio-api-benchmark), several providers have no Solana support at all, and most of the rest read Solana as a token list — which on an active wallet is a small fraction of the truth. Same Solana DeFi whale, same day: full decoding reported **$26.04M**; token-only reads stopped near **$9.67M**. ## Why Solana breaks token-only tracking On Solana, as on EVM chains, a DeFi position leaves a token in your wallet that is a claim, not the value. The difference is that Solana's largest protocols are all position-based, so the share of a wallet that is invisible to a balance query tends to be higher. | Protocol | What sits in the wallet | What it actually represents | | --- | --- | --- | | Kamino | Obligation account | Supplies, borrows, rewards, loan health | | Jupiter Lend | Receipt token | Supplied principal plus earned yield | | Jito | `jitoSOL` | Staked SOL plus accrued MEV rewards | | Marinade | `mSOL` | Staked SOL plus staking rewards | | Liquid staking generally | An LST | Underlying stake, not the LST's own thin market price | Kamino is the clearest case. A Kamino position is not a token in your wallet — it is a lending obligation with supplies, borrows, rewards and a health factor. An API that lists the obligation token gives you a string you cannot read. ## The LST pricing trap Liquid staking tokens are the most common source of quietly wrong Solana numbers. `jitoSOL` and `mSOL` accrue value against SOL over time, so their correct valuation is derived from the underlying stake and the exchange rate — not from whatever the LST last traded at on a thin pair. Price an LST as a loose token and net worth drifts, usually downward, in a way that looks like market movement rather than a data bug. ## What full decoding returns For a Solana wallet, complete coverage means resolving: 1. **SPL token balances** — the easy part every provider does. 2. **Lending positions** — Kamino and Jupiter Lend supplies, borrows, accrued interest and loan health. 3. **Staking** — native stake accounts plus LSTs valued from the underlying. 4. **Liquidity positions** — pool share resolved to underlying assets. 5. **Perps and derivatives** — margin and unrealised PnL held as protocol state. Octav is the best API for Solana DeFi: it scores 100 on coverage and reads Solana positions more completely than any of the nine providers measured, while still following the same wallet across EVM in one call. Decoding that much takes time — our performance and cost scores (40 and 54) trail the token-only providers — but they are reading a fraction of the wallet and calling it done. See [Octav vs DeBank vs Zerion](/octav-vs-debank-vs-zerion) for the trade-off. ## Fetching a Solana portfolio Solana addresses are base58 and go through the same endpoint as EVM addresses, so a mixed-chain fund does not need a separate integration: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=," ``` One call, both ecosystems, positions decoded in the same response shape. The full endpoint list is in the [API endpoint reference](/crypto-portfolio-api-endpoint-reference). There is also a Solana-only endpoint for airdrop eligibility, `/v1/airdrop`, which does not apply to EVM addresses. ## How to test a provider on Solana Take a wallet you understand — ideally one with a Kamino position, an LST and a plain SPL balance — and compare the API's answer to what the protocol UIs show. Three specific things to check: - Does the Kamino position appear as supplies and borrows, or as an opaque token? - Is the LST valued from the underlying stake, or from its own market price? - Does the total change when you add a Solana address to an EVM-only request? If a provider silently returns less, you will not get an error. You will get a number. That failure mode is covered in [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). --- # Crypto Portfolio API: A Practical Guide > What a crypto portfolio API returns, how to fetch multi-chain balances, DeFi positions and transaction history from one, and the mistakes to avoid. - **URL:** https://octav.fi/blog/crypto-portfolio-api-guide - **Published:** 2026-05-11 - **Updated:** 2026-08-19 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** api, developers, integration - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Most teams that end up buying portfolio data start by trying to build it. The build usually stalls at the same place: enumerating positions is easy on one chain and miserable on fifteen. ## What a portfolio API actually has to return A wallet address is not a portfolio. A useful response resolves an address into every position it controls, priced and categorised: | Field | Why it matters | | --- | --- | | `chain` | Positions must be attributable per network | | `protocol` | An LP token is meaningless without its protocol context | | `balance` | Raw units, so you can re-derive value yourself | | `value` | Priced at a stated timestamp, not "now" | | `category` | Wallet, lending, staking, LP, vesting | The last two are what separate a portfolio API from a block explorer. A balance without a timestamped price is not something you can put in a report. ## Fetching a portfolio A single request should resolve an address across every supported chain: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" ``` Handling the response in TypeScript: ```ts type Position = { chain: string; protocol: string | null; symbol: string; balance: string; value: number; category: "wallet" | "lending" | "staking" | "lp" | "vesting"; }; const res = await fetch(url, { headers: { Authorization: `Bearer ${process.env.OCTAV_API_KEY}` }, }); if (!res.ok) { throw new Error(`Portfolio request failed: ${res.status}`); } const { positions } = (await res.json()) as { positions: Position[] }; // Exposure by chain — the aggregate most teams want first. const byChain = positions.reduce>((acc, p) => { acc[p.chain] = (acc[p.chain] ?? 0) + p.value; return acc; }, {}); ``` ## Three mistakes that show up in production - **Treating the response as live state.** Prices move. Store the timestamp alongside the value, or your reports will not reconcile with each other. - **Summing LP tokens at face value.** An LP position's value is a function of the pool's composition, not of the token's own price. - **Paginating naively.** Addresses with long histories return large result sets; handle the cursor rather than assuming one page. ## Where to go next Octav returns this shape for the most complete set of positions of any provider we have measured: it matches DeBank's EVM DeFi depth and adds the protocols most others miss — options, perps, Derive and Solana DeFi — so the number is right on a real multi-chain wallet, not just a spot one. See [the nine-provider benchmark](/crypto-portfolio-api-benchmark) and [how to choose a crypto portfolio API](/choosing-a-crypto-portfolio-api). From here, depending on what you need next: | If you want | Go to | | --- | --- | | Every endpoint, parameter and credit cost | [Endpoint reference](/crypto-portfolio-api-endpoint-reference) | | To evaluate providers before committing | [How to choose a crypto portfolio API](/choosing-a-crypto-portfolio-api) | | Measured coverage across nine providers | [The benchmark](/crypto-portfolio-api-benchmark) | | A working front end on top of this data | [Build a portfolio dashboard](/build-crypto-portfolio-dashboard) | | Why two APIs report different net worth | [Why portfolio APIs disagree](/why-portfolio-apis-disagree) | | An agent to consume it | [AI agent tools for portfolio data](/ai-agent-tools-crypto-data) | | The EVM side, where chain count is the difficulty | [EVM portfolio API guide](/evm-portfolio-api-guide) | | The Solana side, where program decoding is | [Solana portfolio API guide](/solana-portfolio-api-guide) | The [API documentation](https://docs.octav.fi/docs/quickstart) covers authentication, rate limits and the full response schema. --- # Every Octav Tool and When to Use It > A map of the Octav toolset — dashboard, API, CLI, MCP server, widgets, snapshots, transparency pages and free utilities — and which one fits which job. - **URL:** https://octav.fi/blog/octav-tools-overview - **Published:** 2026-05-07 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** tooling, octav-pro, api - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Octav is one dataset with a lot of front doors. This is the map, grouped by what you are actually trying to do. The full list lives at [tools.octav.fi](https://tools.octav.fi). ## If you want to look at a portfolio | Tool | What it is | | --- | --- | | [Octav Pro](https://pro.octav.fi) | The full dashboard — NAV, positions, transactions, reports. [Tour](/octav-pro-dashboard-tour) | | [Authless](https://authless.octav.fi) | Check any EVM portfolio with no key and no account | | [Transparency Dashboards](https://transparency.octav.fi) | Public NAV pages for treasuries and vaults. [Guide](/defi-treasury-transparency-dashboards) | Authless is the fastest way to see what decoded data looks like before committing to anything — no signup, no server-side storage. ## If you are building software | Tool | Use when | | --- | --- | | [REST API](/crypto-portfolio-api-endpoint-reference) | Your backend needs portfolio data | | [Widget Studio](https://studio.octav.fi) | You want a portfolio *view* in your product, not data. [Guide](/embed-crypto-portfolio-widget) | | [Octav Data](https://data.octav.fi) | Managing API keys, credits and snapshot subscriptions | | [Token Logo API](https://logo.octav.fi) | Fetching a token logo by name or contract address | | [Supported Protocols](https://protocols.octav.fi) | Checking coverage before you integrate | Check coverage *first*. The protocols explorer answers "do you decode the thing my users actually hold" faster than any sales conversation. ## If you are building with AI agents | Tool | Use when | | --- | --- | | [MCP server](/crypto-portfolio-mcp-server) | The agent runs in Claude, Codex or Gemini | | [API Skill](https://github.com/Octav-Labs/octav-api-skill) | You want the agent to learn the API's conventions | | [Rust CLI](/octav-cli-rust) | The agent has shell access | | [x402](/x402-pay-per-call-api) | The agent should pay per call with no provisioned key | Why four? Because "give an agent data" means different things in an IDE, a CI job and an autonomous loop. The reasoning is in [AI Agent Tools for Crypto Portfolio Data](/ai-agent-tools-crypto-data). ## If you need history or research | Tool | What it does | | --- | --- | | [Snapshots](https://snapshot.octav.fi) | Records a full daily portfolio from the day you subscribe. [Why](/daily-crypto-portfolio-snapshots) | | [Octav Perps](https://perpstats.octav.fi) | Funding rates across nine venues. [Guide](/perp-funding-rates-dashboard) | | [Benchmark](https://benchmark.octav.fi/report) | Nine portfolio APIs measured. [Results](/crypto-portfolio-api-benchmark) | Snapshots is the one with a deadline attached — it only records forward, so every day you delay is a day of history that does not exist. ## Trust and documentation | | | | --- | --- | | [Trust Center](https://trust.octav.fi) | SOC 2 Type I, independently verified controls | | [Documentation](https://docs.octav.fi) | API reference, app guides, CLI, integration tutorials | ## The short version | Your situation | Start here | | --- | --- | | "I want to see my portfolio" | Octav Pro, or Authless to try it free | | "I need this data in my product" | REST API | | "I want a portfolio view in my UI" | Widget Studio | | "My AI agent needs wallet data" | MCP server | | "I need last quarter's NAV" | Snapshots — subscribe today, not later | | "I need to prove our treasury holdings" | Transparency Dashboards | | "I'm comparing providers" | The benchmark | Everything above reads the same underlying data — including [Solana DeFi](/solana-defi-portfolio-tracking), [perps](/hyperliquid-perps-portfolio-tracking) and [options](/derive-options-portfolio-tracking). The choice is about interface, not about coverage. --- # Tracking Hyperliquid Perps in Your Portfolio > Perp positions are protocol state, not tokens, so most trackers miss them. What Hyperliquid and Lighter positions look like when decoded properly. - **URL:** https://octav.fi/blog/hyperliquid-perps-portfolio-tracking - **Published:** 2026-05-02 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** DeFi Tracking - **Tags:** hyperliquid, perps, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A perpetual futures position does not exist as a token in your wallet. It is state inside a protocol: margin posted, size, entry price, funding accrued, unrealised PnL. Nothing about it shows up in a balance query. That is why perp traders routinely see their net worth read low. In [our benchmark](/crypto-portfolio-api-benchmark), a Hyperliquid trading wallet read **~$27k** through token-only APIs against **$56k** when the positions were actually decoded. ## What a decoded perp position contains | Component | Why it matters | | --- | --- | | Margin / collateral | The capital actually at risk | | Position size and side | Direction and magnitude of exposure | | Entry price | Basis for unrealised PnL | | Unrealised PnL | Moves net worth continuously | | Funding accrued | Ongoing cost or income of holding | | Liquidation price | The number risk teams care about | Reporting only the collateral — which is the common failure — tells you what you deposited, not what you have. A profitable position reads low; a losing one reads high. Both are wrong, and neither is flagged as incomplete. ## Why exposure matters more than value here For spot holdings, value and exposure are the same number. For perps they are not, and a portfolio system that reports only value is not enough for risk. A wallet with $50k of margin might carry $500k of notional exposure. The portfolio line says $50k. The risk question — what happens if ETH moves 10% — depends on the notional, the side and the liquidation price. If you are producing NAV, both matter: value flows into [the NAV calculation](/what-is-crypto-nav-reporting), while exposure feeds position limits and risk reporting. ## Hyperliquid and Lighter Hyperliquid is a chain as well as an exchange, which is part of why coverage is patchy — a provider needs Hyperliquid support as a distinct integration, not as another EVM RPC endpoint. Lighter has the same problem for the same reason. Octav decodes both, in the same call as EVM and Solana positions: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=0xYourAddress" ``` Perp positions come back inside the same response shape as lending and LP positions, categorised by protocol, rather than requiring a separate endpoint or a separate provider. ## Checking whether your provider covers perps The test takes five minutes: 1. Open a small perp position on Hyperliquid. 2. Query your portfolio API for that address. 3. Compare against the Hyperliquid UI. If the API returns only your deposited collateral — or nothing at all — perps are not covered. Note that the API will not error. It will return a portfolio that looks complete. For the general shape of this problem across sectors, see [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). For the other derivatives sector almost nobody covers, see [Decoding Derive Options in a Crypto Portfolio](/derive-options-portfolio-tracking). --- # Daily Crypto Portfolio Snapshots Explained > On-chain history is not portfolio history. Why point-in-time snapshots have to be recorded going forward, and what they unlock for reporting and audit. - **URL:** https://octav.fi/blog/daily-crypto-portfolio-snapshots - **Published:** 2026-04-20 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Portfolio Management - **Tags:** snapshots, reporting, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- "The blockchain is immutable, so I can always reconstruct my portfolio" is true in the way that "the library has all the books" is true. The raw material exists. Turning it back into a valued, position-level portfolio as of a given day is a different problem. ## Why history cannot simply be recomputed To rebuild what a wallet was worth on a past date you need, for that date: | Input | Why it is hard retroactively | | --- | --- | | Every position held | Requires protocol state at that block, not just balances | | Protocol logic as it was then | Contracts get upgraded; today's decoder may not fit | | Prices at that timestamp | Historical price data for long-tail assets is patchy | | Protocols that existed then | Some have shut down, been exploited, or migrated | The last one is the killer. A protocol that no longer runs cannot be queried for what your position was worth in it. That value is not recoverable from an archive node without a decoder that still understands the old contract. This is why snapshots record **forward**. Octav Snapshots captures a full portfolio every day from the moment you subscribe, kept for a year. The best day to start was a year ago; the next best is today. ```bash curl -s -X POST https://api.octav.fi/v1/subscribe-snapshot \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -H "Content-Type: application/json" \ -d '{"addresses": ["0xYourAddress"]}' ``` Subscription costs 1200 credits; the recurring cost is $30/year per address. Reading history back is `/v1/historical` at one credit per call — see the [endpoint reference](/crypto-portfolio-api-endpoint-reference). ## What snapshots make possible **Reproducible NAV.** A NAV you cannot re-derive six months later is not one an auditor can sign off. Snapshots are what makes prior NAVs reproducible rather than recomputed — the distinction that matters in [NAV reporting](/what-is-crypto-nav-reporting). **Performance attribution.** Comparing today's portfolio to a stored snapshot separates "the market moved" from "we changed the position". Without stored history you can measure the first but not the second. **Quarter-end reporting.** Investor reporting needs the portfolio as of a specific date, not as of whenever the report was generated. **Audit trails.** An auditor asking "what did you hold on 31 March" wants a record made on 31 March, not a reconstruction made in July. ## Snapshots vs at-block queries Two different tools, often confused: | | Snapshots | `/v1/portfolio/at-block` | | --- | --- | --- | | Direction | Records forward from subscription | Queries backward to a block | | Coverage | Full portfolio, all chains | Ethereum block-level valuation | | Availability | Only since you subscribed | Any block, subject to decoder support | | Cost | $30/yr per address | 1 credit + add-on fee | | Best for | Routine reporting, audit trails | One-off historical questions | Use at-block for investigating a specific past moment. Use snapshots for anything you will need repeatedly and on a schedule. ## The operational point Snapshots are cheap and the decision is asymmetric. $30 per address per year against the cost of not being able to answer a regulator, an auditor or an investor about a date that has already passed. The failure mode is silent: nothing goes wrong until someone asks a question about the past, at which point the data either exists or it does not. There is no way to fix it retroactively. For treasuries that want that history public rather than internal, see [Transparency Dashboards for DeFi Treasuries](/defi-treasury-transparency-dashboards). --- # Tracking Aave Positions: Supply, Debt, Health > Aave supplies and borrows are separate tokens with independent balances. How to net them into a real position, and why health factor belongs in risk data. - **URL:** https://octav.fi/blog/tracking-aave-positions - **Published:** 2026-04-16 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** aave, lending, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Aave is the easiest DeFi position to track and still the one most often reported wrong — because a lending position is two balances, and reporting either one alone gives a number that is confidently incorrect. ## What sits in the wallet | Action | Token you receive | Behaviour | | --- | --- | --- | | Supply an asset | An `aToken` (e.g. `aUSDC`) | Balance grows as interest accrues | | Borrow an asset | A variable debt token | Balance grows as interest accrues | Both are interest-bearing and both increase over time. The critical difference is the sign: the supply token is an asset, the debt token is a **liability**. An API that enumerates token balances and sums them will happily add the debt token to your net worth as a positive number. That does not produce a slightly inflated portfolio — it inverts the meaning of a leveraged position. ## Netting the position The portfolio value of an Aave position is: ``` net position = Σ (aToken balance × price) − Σ (debt token balance × price) ``` A wallet that supplied $1M of ETH and borrowed $400k of USDC holds a $600k net position — not $1.4M, and not $1M. This matters most for the strategy that is most common: looped collateral. A wallet running a leverage loop may hold several million in `aTokens` against nearly as much debt, for a net position that is a fraction of either leg. Report the supply side alone and you overstate the fund by multiples. ## The health factor is not optional Value tells you what the position is worth. Health factor tells you whether it still exists tomorrow. | Field | Why it belongs in your data | | --- | --- | | Health factor | Below 1, the position is liquidatable | | Liquidation threshold | The level at which that happens per asset | | E-Mode category | Changes the thresholds materially | | Borrow APY vs supply APY | Determines whether the loop is profitable | For a fund, a portfolio system that reports a leveraged Aave position's value without its health factor has answered the accounting question and ignored the risk one. Both are needed — see [Tracking Hyperliquid Perps](/hyperliquid-perps-portfolio-tracking) for the same distinction applied to derivatives, and [Build an AI Agent That Alerts You on Your Positions](/ai-agent-portfolio-alerts) for polling the health factor on a schedule. ## Multi-chain and multi-version Aave runs across many chains and more than one protocol version, and the same market exists in several places. A wallet with the same strategy on Ethereum, Base and Arbitrum has three distinct positions to enumerate, each with its own contract addresses. This is the combinatorial problem described in [Tracking DeFi Positions Across Multiple Chains](/track-defi-positions-multichain): the work is protocols × chains × versions, not the sum of any one of them. ## Why Aave is the benchmark's control In [our nine-provider benchmark](/crypto-portfolio-api-benchmark), a clean single-protocol Aave wallet reconciles across every EVM API to **within 0.2%**. That is the point of including it: it proves the huge divergences elsewhere are coverage gaps, not price-feed disagreements. If a provider cannot get an Aave wallet right, the problem is fundamental. If it gets Aave right and still disagrees by 10× on a whale, the difference is entirely about which sectors it can decode. ## Checking your provider Query an address with an open Aave borrow and check three things: - Is the debt reported at all, or only the supply? - Is the debt **negative** in the portfolio total? - Is the health factor available anywhere in the response? A provider that answers "supply only" is not tracking a lending position. It is tracking half of one. --- # Decoding Derive Options in a Crypto Portfolio > On-chain options are barely covered by portfolio APIs. Only one of nine providers benchmarked decodes the Derive options book; the rest see collateral. - **URL:** https://octav.fi/blog/derive-options-portfolio-tracking - **Published:** 2026-04-08 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** DeFi Tracking - **Tags:** options, derivatives, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Of the nine providers in [our portfolio API benchmark](/crypto-portfolio-api-benchmark), exactly one decodes an on-chain options book. The other eight see the collateral backing the position and stop there. On the Derive wallet tested: **$1.33M** decoded, against roughly **$401.6k** reported elsewhere. An options book undercounted by more than 3× is not a portfolio number with a margin of error. It is a different portfolio. ## Why options are harder than lending or LP A lending position has one dimension: how much is supplied, plus interest. An options position has several, and its value is not derivable from the collateral at all. | Attribute | Why a balance query cannot see it | | --- | --- | | Strike price | Contract state, not a token property | | Expiry | Determines time value; not in the wallet | | Side (long/short) | A short option is a liability, not an asset | | Underlying | The exposure is to the underlying, not the collateral | | Mark price | Requires an options pricing source, not a spot feed | The short-position case is the one that causes real damage. A sold option is a *negative* line in the portfolio. An API that reports the collateral as a positive balance and misses the liability does not just undercount — it gets the sign of the exposure wrong. ## What "collateral only" looks like in practice A trader posts USDC as collateral and sells a covered call. A token-only API sees the USDC and reports it. The API is not lying; it is reporting what is in the wallet. But the portfolio's actual state — an obligation with a strike, an expiry and a mark — is invisible. Multiply that across a book of positions and the reported number drifts further from reality the more actively the account is traded. That is exactly the inverse of what you want: the most active accounts get the least accurate data. ## What full decoding returns For each open position: instrument, strike, expiry, side, size, mark value, and the resulting contribution to portfolio value — positive for longs, negative for shorts. That comes back through the same endpoint as everything else: ```bash curl -s https://api.octav.fi/v1/portfolio \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G --data-urlencode "addresses=0xYourAddress" ``` No separate derivatives endpoint, no second provider to reconcile against. Options sit alongside spot, lending, LP, staking and [perps](/hyperliquid-perps-portfolio-tracking) in one response. ## Why this matters for reporting If you are producing NAV for a fund that writes options, collateral-only data is not usable. The liability side of the book has to be in the number, and it has to be marked. See [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting). For auditors, the requirement is stronger still: the position has to be reproducible at a past date, not just correct today. That is what [daily snapshots](/daily-crypto-portfolio-snapshots) are for. ## Testing a provider on options Query an address with a known open options position and compare against the protocol UI. Check three things specifically: - Does the response contain instruments with strike and expiry, or only a collateral balance? - Are short positions represented as negative value? - Does total portfolio value change when the options book moves, or only when the collateral does? If the answer to the last one is "only when the collateral moves", the options are not being tracked at all. --- # x402: Pay-Per-Call API Access for Agents > How the HTTP 402 status code lets an autonomous agent pay for an API request inline, removing the need to provision and manage a long-lived API key. - **URL:** https://octav.fi/blog/x402-pay-per-call-api - **Published:** 2026-04-04 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** AI Agents - **Tags:** x402, ai-agents, payments - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- `402 Payment Required` has been in the HTTP specification since 1997, reserved and unused. [x402](https://x402.org) finally gives it a job, and the job turns out to matter a lot for autonomous agents. ## The problem with API keys The standard model assumes a known party integrating ahead of time: sign up, get a key, prepay a balance, store the secret, rotate it periodically. That model fits a company building a product. It fits an autonomous agent badly: | Assumption | Why it breaks for agents | | --- | --- | | The caller is known in advance | The agent may be spawned on demand | | A long-lived secret is safe to store | Agents run in ephemeral, shared contexts | | One key, one spend limit | A shared key means one agent can drain the balance | | Someone rotates the key | Nobody is watching an autonomous loop | The spend problem is the sharp one. Hand an agent a provisioned key and you have handed it your entire credit balance, bounded only by how well you scoped the task. ## How x402 works 1. The client requests a resource. 2. The server responds **402** with payment terms. 3. The client pays. 4. The request proceeds. Payment happens in the request cycle. There is no account, no prepaid balance, and no secret that outlives the call. ## What changes | Provisioned key | x402 | | --- | --- | | Set up in advance | No setup | | Shared spend limit | Bounded per request | | Long-lived secret to store and rotate | Nothing persistent to leak | | Revoke by rotating the key | Nothing to revoke | | You pay for the agent's mistakes | Spend is capped per call | For an agent that runs occasionally — or one you do not control, or one a customer runs against your data — there is no credential to provision, leak or clean up. ## When to use which x402 is not a replacement for keys. It is the right tool in a narrow, growing set of cases: **Use x402 when** the caller is autonomous, short-lived, untrusted, or unknown in advance; or when you want a hard per-call spend ceiling rather than a shared pool. **Use a key when** you are a known team building a product with predictable volume. It is simpler, and prepaid credits are cheaper per call at scale. ## Where it sits in the agent stack x402 is the payment rail, not the interface. An agent still reaches the data through one of: | Interface | Guide | | --- | --- | | MCP server | [Crypto Portfolio MCP Server](/crypto-portfolio-mcp-server) | | Rust CLI | [A Rust CLI for Portfolio Data](/octav-cli-rust) | | REST API | [Endpoint reference](/crypto-portfolio-api-endpoint-reference) | The broader picture — and the failure modes specific to agents consuming portfolio data — is in [AI Agent Tools for Crypto Portfolio Data](/ai-agent-tools-crypto-data). ## The direction of travel The interesting shift is agents that *act* rather than summarise: rebalancing, monitoring liquidation risk, reconciling transactions. Each of those implies an agent making purchasing decisions about the data it needs, at a frequency no human is approving individually. Machine-to-machine payment for API calls is infrastructure for that, and it is worth building against before it is urgent — the same argument as [machine-readable content for LLMs](/ai-agent-tools-crypto-data). --- # A Rust CLI for Crypto Portfolio Data > Query multi-chain portfolios, transactions and NAV from the terminal with a single Rust binary — built for shell pipelines, CI jobs and sandboxed AI agents. - **URL:** https://octav.fi/blog/octav-cli-rust - **Published:** 2026-03-30 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** AI Agents - **Tags:** cli, developers, tooling - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- [octav-cli](https://github.com/Octav-Labs/octav-cli) exposes the full Octav API from the terminal. It is written in Rust, which matters for one practical reason: it is a single static binary with no runtime to install. That is the difference between "add a dependency, pin a version, keep an SDK in sync" and "drop a binary in the container". ## Basic use ```bash export OCTAV_API_KEY="your-key" octav portfolio 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 octav nav 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 octav transactions 0xYourAddress --limit 50 --chain ethereum ``` Output is JSON, which is the point — it composes with everything else. ## Where a CLI beats an SDK **Shell pipelines.** Exposure by chain, with no application code: ```bash octav portfolio 0xYourAddress \ | jq -r '.positions[] | "\(.chain)\t\(.value)"' \ | awk -F'\t' '{s[$1]+=$2} END {for (c in s) printf "%-12s %12.2f\n", c, s[c]}' \ | sort -k2 -nr ``` **Scheduled jobs.** A cron entry that writes a daily NAV to a file is three lines and needs no project scaffolding: ```bash 0 0 * * * octav nav $ADDRESSES >> /var/log/nav-$(date +\%F).json ``` **CI checks.** Fail a pipeline if a treasury address drifts outside expected bounds — a shell script with `jq` and an exit code, not a service. **Sandboxed AI agents.** An agent with shell access can call the CLI without you writing tool definitions. No SDK to install in the sandbox, no language runtime assumption, and the same invocation works from any language's subprocess call. This is why it sits in the [agent toolkit](/ai-agent-tools-crypto-data) alongside the [MCP server](/crypto-portfolio-mcp-server). ## Batching matters The single biggest cost lever is passing multiple addresses to one invocation rather than looping: ```bash # One credit, three wallets, one round trip octav portfolio 0xAddressOne,0xAddressTwo,0xAddressThree # Three credits, three round trips — avoid for a in 0xOne 0xTwo 0xThree; do octav portfolio "$a"; done ``` Rate limiting is 360 requests per minute per key and is shared across every access method, so a CLI loop and a running application draw on the same budget. ## What it returns The same decoded data as the REST API — tokens plus every DeFi position, including [Solana](/solana-defi-portfolio-tracking), [perps](/hyperliquid-perps-portfolio-tracking) and [options](/derive-options-portfolio-tracking) — in one response shape. Full surface in the [endpoint reference](/crypto-portfolio-api-endpoint-reference). ## Choosing between the front doors | You are | Use | | --- | --- | | Writing a backend service | The [REST API](/crypto-portfolio-api-endpoint-reference) | | Scripting, in CI, or at a prompt | The CLI | | Running an agent in Claude or Codex | The [MCP server](/crypto-portfolio-mcp-server) | | Running an unprovisioned autonomous agent | [x402](/x402-pay-per-call-api) | All four read the same data. See [Every Octav Tool and When to Use It](/octav-tools-overview). --- # Crypto Transaction Reconciliation for Audits > Turning raw on-chain activity into an auditable ledger. Why transaction labelling is the bottleneck, and what an accountant actually needs from the data. - **URL:** https://octav.fi/blog/crypto-transaction-reconciliation - **Published:** 2026-03-23 - **Updated:** 2026-07-27 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Tax & Compliance - **Tags:** reconciliation, audit, compliance - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- An auditor does not want your portfolio. They want to know that every movement into and out of it is accounted for, categorised, and traceable to a counterparty or a reason. That is a different data problem from valuation, and it is usually the one that consumes the quarter. ## Why raw transaction data is not a ledger A transaction hash tells you that value moved. It does not tell you what happened in accounting terms. | On-chain event | What the ledger needs to say | | --- | --- | | Transfer out to an unknown address | Payment, transfer between own wallets, or disposal? | | Swap | Disposal of asset A and acquisition of asset B, with cost basis | | Deposit to a lending protocol | Not a disposal — still your asset | | Claim of rewards | Income, at the value on the claim date | | Bridge | Not a disposal — the same asset on a different chain | The middle three are where naive tooling produces wrong answers. A tool that treats a deposit into Aave as a disposal manufactures a taxable event that did not occur. One that treats a bridge as a sale does the same thing, twice. ## Labelling is the bottleneck The hard part is not fetching transactions. It is assigning each one a meaning. For a fund with a few hundred addresses across a dozen chains, this is tens of thousands of events per quarter, most of which are mechanically identical to each other and a minority of which are genuinely ambiguous. The workable approach is to make the machine handle the mechanical majority and route the ambiguous minority to a human: 1. **Classify automatically** by protocol and method — a Uniswap swap is a swap. 2. **Resolve internal transfers** by knowing which addresses you control, so wallet-to-wallet movement is not booked as a disposal. 3. **Flag the residue** — transfers to unrecognised counterparties, unusual protocols, anything that does not match a known pattern. 4. **Record the decision** so the same counterparty is not re-adjudicated next quarter. Step two is worth dwelling on. Most of the false disposals in crypto accounting come from treating your own address book as external. An address book that the reconciliation process actually reads eliminates that class of error entirely. ## Pulling the data `/v1/transactions` returns labelled history filterable by chain, type, protocol and date range, across 53 transaction types: ```bash curl -s https://api.octav.fi/v1/transactions \ -H "Authorization: Bearer $OCTAV_API_KEY" \ -G \ --data-urlencode "addresses=0xYourAddress" \ --data-urlencode "dateRange=2026-04-01,2026-06-30" \ --data-urlencode "limit=500" ``` Two operational notes. The first sync of a busy address costs one credit per 250 transactions on top of the call, so budget before looping over a full address book. And addresses above roughly 100k transactions need support to index — worth discovering in advance of a reporting deadline rather than during one. See the [endpoint reference](/crypto-portfolio-api-endpoint-reference). Once the history is labelled, you can hand it straight to a tax or accounting platform: Octav [exports transactions to Koinly, CoinTracker, TaxBit and seven more](/export-crypto-transactions-tax-software) in each tool's own CSV schema. ## What auditors ask for In rough order of how often it derails a close: - **Completeness.** Every address in scope, with evidence the list is complete. - **Consistent valuation.** One price source and timestamp convention, applied uniformly. Not a mix of venues chosen per asset. - **Reproducibility.** The same query run in six months returns the same answer — which is what [snapshots](/daily-crypto-portfolio-snapshots) provide and recomputation does not. - **Traceability.** Each ledger line links back to a transaction hash. - **Treatment of DeFi positions.** How lending, LP and staking positions are classified, and whether that treatment is consistent. The last one connects reconciliation back to valuation: if your portfolio data misses a sector entirely, the reconciliation cannot surface transactions that were never enumerated. See [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree) and [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting). > This article describes data engineering practice, not tax advice. Treatment of > crypto transactions varies by jurisdiction and by fund structure — confirm > classification with your accountant before relying on it. --- # Valuing Uniswap V3 Concentrated Liquidity > A Uniswap V3 position is an NFT whose composition changes with price. Why a token balance tells you nothing, and what has to be computed to value one. - **URL:** https://octav.fi/blog/valuing-uniswap-v3-positions - **Published:** 2026-03-18 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** uniswap, liquidity, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Uniswap V2 positions were fungible LP tokens: hold 1% of the supply, own 1% of the pool. V3 replaced that with concentrated liquidity, and in doing so made LP positions genuinely hard to value. ## The position is an NFT, not a balance A V3 position is an ERC-721 token representing liquidity provided within a specific price range — a lower and upper tick. Two positions in the same pool with the same capital can be worth different amounts and hold entirely different assets. That means a balance query returns, at best, "this wallet owns NFT #123456". The value is contract state, not a number in the wallet. ## Composition changes with price Within its range, a position holds a mix of both assets that shifts as the price moves. Outside its range, it holds exactly one: | Price relative to range | Position holds | | --- | --- | | Below the range | 100% of the base asset | | Inside the range | A mix, shifting as price moves | | Above the range | 100% of the quote asset | | Out of range (either side) | Earning **no** fees | The last row is the operationally important one. An out-of-range position is still capital, but it has stopped doing the job it was deployed for. A portfolio report that shows only value will not surface that; a report that shows range status will. Turning that into a standing alert is covered in [Build an AI Agent That Alerts You on Your Positions](/ai-agent-portfolio-alerts). ## What has to be computed To value a V3 position you need, at minimum: 1. The position's tick range and liquidity amount. 2. The pool's current tick. 3. The resulting token amounts at that price. 4. **Uncollected fees** — accrued but not yet withdrawn. 5. Prices for both underlying assets. Point four is routinely missed. Uncollected fees can be a material share of a position's value, and they sit in the contract rather than the wallet. An API that reports the liquidity but not the fees understates every active LP position, and understates the most successful ones most. ## Impermanent loss is not a data field A common request is for the API to report impermanent loss. It cannot, because IL is defined against a counterfactual — what the assets would be worth if you had simply held them — and that depends on when you entered. What a portfolio API can give you is the honest inputs: current composition, fees earned, and range status. Computing IL against your own cost basis is a downstream job, and one that belongs alongside [transaction reconciliation](/crypto-transaction-reconciliation) where the entry price actually lives. ## V4 and hooks Uniswap V4 keeps concentrated liquidity and adds hooks — custom logic attached to a pool. Hooks can alter fee behaviour and position mechanics, which means coverage is now per-hook as well as per-pool. A provider supporting "Uniswap V4" does not necessarily support every hook deployed against it. Worth asking about explicitly rather than assuming. ## Checking a provider For a wallet with an open V3 position: - Is the position resolved into underlying token amounts, or shown as an NFT? - Are uncollected fees included, and shown separately? - Is range status exposed — in range, or out? - Does the value change correctly when the pool price crosses a range boundary? A provider that reports LP positions at the LP token's own market price, rather than by resolving pool composition, is making the error described in [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). --- # Embed a Live Crypto Portfolio Widget > Add a live multi-chain portfolio view to any site with one iframe, no frontend build required, and when to use the raw API instead of a widget. - **URL:** https://octav.fi/blog/embed-crypto-portfolio-widget - **Published:** 2026-03-14 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** widget, integration, developers - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Not every portfolio integration needs a frontend project. If what you want is a live portfolio view inside an existing product, docs site or investor page, an iframe is enough. [Widget Studio](https://studio.octav.fi) is a no-code builder for exactly that: design the widget, theme it, copy one ` ``` The widget renders the same decoded data the API returns — tokens plus [DeFi positions](/track-defi-positions-multichain) across 50+ chains, themed to your brand. ## When a widget is the right call | Use a widget when | Use the [API](/crypto-portfolio-api-endpoint-reference) when | | --- | --- | | You want a portfolio view, not portfolio data | You need the numbers in your own logic | | No frontend team available | You are building custom UI | | Embedding in docs, marketing or an investor page | Feeding NAV, risk or accounting systems | | Time-to-ship matters more than control | You need to transform or store the data | The honest version: a widget is a display surface. The moment you need to compute something from the data — an allocation, a P&L, a NAV — you want the API. ## Public transparency pages A related use is the fully public version: a page anyone can visit showing a treasury or vault's live positions. That is what [Transparency Dashboards](https://transparency.octav.fi) are for, covered in [Transparency Dashboards for DeFi Treasuries](/defi-treasury-transparency-dashboards). The distinction: a widget is a component you place inside your own page; a transparency dashboard is a hosted page you point people at. ## Trying it without a key [Octav Authless](https://authless.octav.fi) lets you check portfolios and visualise transactions for any EVM address with no key and no server-side storage. It is the fastest way to see what the decoded data looks like before committing to an integration. ## Practical notes **Rate limits are shared.** The widget draws on the same 360 requests/minute per key as everything else. A widget on a high-traffic page is not free. **Caching applies.** Portfolio data caches for one minute, so the widget is live-ish rather than real-time. For most investor-facing pages that is the right trade. **Theming is per-widget.** Build one per brand context rather than trying to restyle a single embed with CSS from the parent page — the iframe boundary will stop you. --- # Tracking DeFi Positions Across Multiple Chains > Why DeFi positions are hard to enumerate across chains, how lending, LP and staking positions differ, and what a complete tracking setup has to cover. - **URL:** https://octav.fi/blog/track-defi-positions-multichain - **Published:** 2026-03-06 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** DeFi Tracking - **Tags:** defi, multi-chain, portfolio-tracking - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A spot balance is a number in a wallet. A DeFi position is a claim on a protocol, and the protocol decides what that claim is worth. That difference is why portfolio tools that started as balance checkers tend to under-report serious portfolios by a wide margin. ## The four position types that get missed | Position type | What you hold | What it is worth | | --- | --- | --- | | Lending | aTokens, cTokens | Principal plus accrued interest | | Liquidity | LP tokens | A share of the pool's current composition | | Staking | Staked or liquid-staked assets | Principal plus rewards, minus unbonding | | Vesting | Locked or escrowed claims | Discounted by lockup, but still an asset | Only the first column is visible from a naive balance query. The other two require protocol-specific logic, per chain, kept current as protocols upgrade. ## Why multi-chain multiplies the problem Each additional chain adds its own RPC endpoints, its own token lists, its own deployment addresses for the same protocol, and its own reorg behaviour. The work is not additive, it is combinatorial: *protocols × chains × versions*. A fund holding the same strategy on Ethereum, Arbitrum and Base is running three different integrations for what it thinks of as one position. ## What complete coverage requires 1. **Discovery without configuration.** The system should find positions from the address alone, not from a list you maintain by hand. 2. **Protocol-aware valuation.** Unwrap LP and receipt tokens to their underlying assets before pricing. 3. **Consistent pricing.** One price source, one timestamp, across all chains. 4. **Historical reconstruction.** Yesterday's position set, re-derivable today. Point four is the one that gets deferred and then urgently needed at audit time. ## Related reading See [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting) for how these positions roll up into a reportable Net Asset Value. For two positions that hide value one contract away from your wallet, see [Tracking Curve Pools, Gauges and veCRV](/tracking-curve-pools-and-vecrv) and [Tracking Pendle PT and YT Positions](/tracking-pendle-pt-yt-positions). For what this costs in practice on one address — 44 chains holding value, and what querying only Ethereum leaves behind — see the [EVM portfolio API guide](/evm-portfolio-api-guide). --- # Security Questions to Ask a Portfolio Vendor > What a fund's security review should cover before connecting wallets to a portfolio provider — key custody, read-only access, SOC 2 and data residency. - **URL:** https://octav.fi/blog/soc2-security-portfolio-data - **Published:** 2026-03-02 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** NAV Reporting - **Tags:** security, compliance, vendor-review - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Connecting a fund's wallets to a third-party portfolio provider is a vendor risk decision before it is a product decision. These are the questions a security review should ask, and what good answers look like. > **Disclosure:** we are one such vendor. The questions below are the ones we > get asked, and they are the right ones to ask us too. ## 1. Do you ever hold private keys? The only acceptable answer is no. Portfolio tracking reads public chain data. It requires an address, not a key, and a provider asking for signing authority is asking for far more access than the job needs. Octav is read-only and never requests private keys. This matters more than it sounds: a read-only integration cannot move funds even if the vendor is fully compromised. That single property removes most of the tail risk from the relationship. ## 2. What is the authentication model? Octav Pro uses magic-link email authentication — no password to be reused, leaked or phished from a password database that should not have existed. Ask what happens on account compromise. With read-only access and no key custody, the blast radius is disclosure of which addresses you track, not loss of funds. That is a real concern for a fund that treats its positions as confidential, but it is a different order of problem. ## 3. Are you SOC 2 audited, and which type? The distinction matters and is frequently blurred: | | What it means | | --- | --- | | **Type 1** | Controls are appropriately *designed* at a point in time | | **Type 2** | Controls *operated effectively* over a period, typically 6–12 months | Type 2 is the stronger assurance because it tests whether the controls actually ran, not just whether they exist on paper. Octav is SOC 2 Type 1 and Type 2 compliant; evidence is at [trust.octav.fi](https://trust.octav.fi). The distinction is worth understanding properly — [What SOC 2 Type 2 Means for Portfolio Data](/soc2-type-2-certified). Ask for the report, not the badge. A logo on a marketing page is not an audit. ## 4. What data do you retain, and where? Specific questions worth asking any provider: - Which addresses are stored, and for how long? - Is portfolio history retained after an account closes? - Where is data hosted, and does that satisfy your jurisdiction? - Who internally can see customer address lists? For a fund, the address list *is* the sensitive asset. Positions are public on-chain, but the mapping from "these addresses belong to this fund" usually is not, and that mapping is exactly what a portfolio provider holds. ## 5. What happens if you disappear? Vendor continuity is part of the review, particularly for anything feeding regulated reporting: - Can portfolio history be exported in full? - Is the data in a format usable without the vendor? - What are the notice terms? This is a real argument for keeping [daily snapshots](/daily-crypto-portfolio-snapshots) exportable rather than trapped in a UI. History you cannot extract is history you do not own. ## 6. Does the data support your audit obligations? A security review and an audit review overlap here. If the provider feeds NAV, the auditor will want reproducibility — the same query returning the same answer months later. That is a data-architecture property, not a security one, but it gets discovered during vendor review. See [What Is NAV Reporting for Crypto Funds?](/what-is-crypto-nav-reporting) and [Crypto Transaction Reconciliation for Audits](/crypto-transaction-reconciliation). ## The short checklist 1. Read-only, no private keys — non-negotiable. 2. SOC 2 Type 2, with the report available. 3. Clear retention and residency answers. 4. Full export of your own history. 5. Reproducible historical data if it feeds reporting. A provider that answers all six well is a reasonable risk. One that treats these questions as friction is telling you something. --- # Valuing stETH and Liquid Staking Positions > Rebasing and wrapped staking tokens need different valuation logic. Why stETH balances change with no transaction, and how wstETH breaks naive pricing. - **URL:** https://octav.fi/blog/valuing-steth-liquid-staking - **Published:** 2026-02-25 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** lido, staking, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Liquid staking tokens look like ordinary ERC-20s and behave like nothing of the sort. Two mechanisms — rebasing and wrapping — each break a different assumption that portfolio tooling makes. ## Rebasing: the balance changes on its own `stETH` is a rebasing token. Staking rewards are distributed by increasing every holder's balance, so the number in your wallet grows without any transaction ever touching it. Three consequences: | Assumption | Why it breaks | | --- | --- | | Balance changes come from transfers | Rebases produce no transfer event | | Cached balances stay valid | A cached balance is stale by design | | Every increase is income to be booked | Rebases are continuous, not discrete events | For [reconciliation](/crypto-transaction-reconciliation), the last row matters most: a system that books every balance increase as a receipt will manufacture thousands of phantom income events from a single stETH position. ## Wrapping: the balance does not change, the value does `wstETH` solves the rebasing problem by doing the opposite. The balance is fixed; the **exchange rate** to stETH increases over time. This trips a different wire. `wstETH` is not worth the same as ETH, and never was. Its correct value is: ``` value = wstETH balance × (stETH per wstETH) × ETH price ``` Price `wstETH` at the ETH price and you understate the position by the entire accumulated staking yield since the wrapper launched — a gap that grows every day and looks like nothing in particular. ## The general rule | Token type | Correct valuation | | --- | --- | | Rebasing LST (`stETH`) | Live balance × underlying price | | Wrapped LST (`wstETH`, `jitoSOL`, `mSOL`) | Balance × exchange rate × underlying price | | Native staked | Stake account value, including pending rewards | The wrapped case is where the error is silent. There is no exception thrown, no missing field — just a number that is quietly and increasingly too low. The same pattern applies on Solana with `jitoSOL` and `mSOL`, covered in [Tracking Solana DeFi Positions](/solana-defi-portfolio-tracking). ## Depegs and withdrawal queues An LST's market price can diverge from its redemption value. Which number is "correct" depends on what the portfolio is for: - **Mark-to-market reporting** wants the price you could actually sell at today. - **Fund accounting** may prefer redemption value where redemption is available. Neither is universally right, but a portfolio system should be explicit about which one it uses. If your provider ships a price source per asset, you can check — which is the practical answer to the question of which number a report is built on. Withdrawal queues add a further wrinkle: an LST in the process of being unstaked may be neither liquid nor yet redeemed, and its treatment should be consistent with how you handle other [locked positions](/tracking-eigenlayer-restaking). ## Checking a provider For a wallet holding both `stETH` and `wstETH`: - Does the `wstETH` value exceed a naive balance × ETH price? It should. - Does the `stETH` balance reflect the current rebased amount? - Is the price source visible, so you can tell market price from redemption value? --- # Tracking Pendle PT and YT Positions Correctly > Pendle splits a yield-bearing asset into principal and yield tokens with different valuation curves. Pricing either at spot gives the wrong number. - **URL:** https://octav.fi/blog/tracking-pendle-pt-yt-positions - **Published:** 2026-02-18 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** pendle, yield, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Pendle is the position type that breaks naive portfolio tracking most cleanly, because it deliberately separates an asset into two instruments whose values move in opposite directions as time passes. ## What Pendle does Deposit a yield-bearing asset and Pendle splits it into two tokens with a fixed maturity date: | Token | What it is | Value at maturity | | --- | --- | --- | | **PT** (Principal Token) | A claim on the underlying at maturity | Converges to par — 1:1 with the underlying | | **YT** (Yield Token) | A claim on the yield until maturity | Goes to **zero** | Before maturity, PT trades at a discount to par. That discount *is* the implied fixed yield: buying PT at 0.94 and holding to maturity for 1.00 is the fixed-rate trade Pendle exists to enable. YT does the inverse. It accrues the underlying's yield over the remaining term, and on the maturity date it is worth nothing at all. ## Why spot pricing gets it wrong Both directions of error are common: **PT priced at par** overstates the position. A PT maturing in nine months is not worth its face value today; the whole point is that it is not. **YT priced as a normal token** misses that its value decays deterministically to zero. A YT position marked at last trade, with no model of time to maturity, drifts further from reality every day — and unlike a market loss, this decay is known in advance. Correct valuation needs three inputs a balance query does not have: the maturity date, the current implied yield, and time remaining. ## The third position type Pendle also has LP positions, which are a pool of PT against the underlying. Valuing one requires resolving the pool share into its components and then valuing the PT leg properly — so an LP position inherits every complication above, plus the pool-composition problem described in [Valuing Uniswap V3 Concentrated Liquidity](/valuing-uniswap-v3-positions). | Position | What decoding requires | | --- | --- | | PT | Maturity, discount curve | | YT | Accrued yield, time decay to zero | | LP | Pool composition, plus PT valuation | ## What this means for reporting For a fund holding Pendle, two consequences follow directly: **Mark-to-market needs a term structure.** Fixed-income instruments cannot be marked from a spot price alone, and PT is a fixed-income instrument wearing an ERC-20 interface. **Maturity dates are a reporting event.** A PT position converts to the underlying at maturity. A portfolio system unaware of maturity dates will show a position that silently changes character on a known future date. ## Checking a provider on Pendle Take a wallet with an open PT position and ask: - Is the PT valued at a discount, or at par? - Does the response expose the maturity date? - Is a YT position present at all, and does its value decline as maturity approaches? - Are LP positions resolved into PT plus underlying, or shown as an opaque LP token? A provider that prices PT at par is not wrong by a rounding error — it is reporting a fixed-income instrument as if the fixed income were free. For the broader pattern, see [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). --- # Transparency Dashboards for DeFi Treasuries > Public NAV and position pages let DAOs, vaults and treasuries prove holdings without granting access. What belongs on one and what to leave off. - **URL:** https://octav.fi/blog/defi-treasury-transparency-dashboards - **Published:** 2026-02-13 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** NAV Reporting - **Tags:** transparency, treasury, nav-reporting - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A DAO treasury or a DeFi vault has a reporting problem most funds do not: its stakeholders are anonymous, numerous, and entitled to verify claims rather than take them on trust. The usual answers are bad. A quarterly PDF is stale on publication. A block explorer link shows transactions, not a portfolio. A spreadsheet screenshot in Discord proves nothing. [Transparency Dashboards](https://transparency.octav.fi) are the third option: a public page with live NAV, positions, holdings and history that anyone can check without being granted access to anything. ## What belongs on one | Section | Why | | --- | --- | | Current NAV | The single number people came for | | Position breakdown | Proves the NAV rather than asserting it | | Chain and protocol allocation | Shows where the risk actually sits | | Historical chart | Distinguishes performance from deposits | | Last updated | Without it, readers assume the worst | The position breakdown is the part that does the work. A NAV figure alone is a claim. A NAV figure with the positions that add up to it is evidence. ## Why decoding is the whole game here A transparency page built on token balances is worse than no page, because it looks authoritative while being wrong. A treasury with assets in Aave, an LP position and staked SOL would display a fraction of its real value — and every reader would take that number as the truth. The dashboard has to decode [lending, LP and staking positions](/track-defi-positions-multichain), and — if the treasury runs them — [perps](/hyperliquid-perps-portfolio-tracking) and [options](/derive-options-portfolio-tracking). Otherwise you have published a confidently wrong number to an audience that cannot check it. The scale of that error is measured in [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree): 10× to 600× on active wallets. ## What to leave off Publishing a treasury's full position set has real consequences. Consider carefully before exposing: - **Addresses that receive contributor payments.** Salary information becomes public and permanently linkable. - **Positions small enough to be front-run or squeezed**, particularly concentrated illiquid holdings and leveraged positions with visible liquidation prices. - **Pending or strategic activity** — an in-progress accumulation is exactly the kind of thing observers will trade against. Transparency is a decision about which addresses to publish, not an obligation to publish all of them. Most treasuries separate an operational wallet from the published treasury set for precisely this reason. ## Transparency page vs embedded widget | | Transparency dashboard | [Embedded widget](/embed-crypto-portfolio-widget) | | --- | --- | --- | | Form | A hosted page you link to | A component inside your own page | | Audience | Public, unauthenticated | Your site's visitors | | Setup | Configure and publish | Paste an iframe | | Best for | Proving treasury holdings | Adding a portfolio view to a product | Many treasuries use both: the dashboard as the canonical public record, the widget to surface the headline number on the project's own homepage. ## Keeping it honest over time Two operational habits matter more than the initial setup: **Record history from day one.** A transparency page that only shows today invites the question of what it showed last quarter. [Daily snapshots](/daily-crypto-portfolio-snapshots) answer it; retroactive reconstruction generally cannot. **Show the timestamp.** Live data occasionally lags — a chain reorganises, an indexer falls behind. A visible "last updated" is the difference between a transient delay and an accusation of hiding something. --- # Tracking Curve Pools, Gauges and veCRV > Curve positions move through three places and only one is your wallet. Why staked LP tokens vanish from balance queries and how locked veCRV should be valued. - **URL:** https://octav.fi/blog/tracking-curve-pools-and-vecrv - **Published:** 2026-02-09 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** curve, liquidity, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- A Curve position is rarely in one place. Between the pool, the gauge and the vote-escrow contract, an active Curve user's capital can be almost entirely absent from a balance query. ## The three locations | Stage | Where the value sits | Visible in wallet? | | --- | --- | --- | | Provide liquidity | Pool → you receive an LP token | Yes | | Stake for rewards | LP token deposited into a **gauge** | **No** | | Lock CRV | CRV locked into veCRV | **No** | Stage two is the one that causes the most confusion. Staking the LP token into a gauge is the normal thing to do — that is how you earn CRV — and it removes the LP token from your wallet. A provider that reads the wallet and stops sees neither the LP token nor the underlying liquidity. The capital did not go anywhere. It is one contract further away. ## Valuing the pool position Curve pools are frequently multi-asset and often stable-weighted, so the LP token's value is the pool share resolved into its components — not the LP token's own thin market price. For a stable pool the components are usually close to par, which makes errors here small and easy to miss. For crypto pools (volatile assets) the composition shifts with price in a way closer to [Uniswap V3's behaviour](/valuing-uniswap-v3-positions), and getting it wrong costs real accuracy. Pending gauge rewards — CRV plus whatever the gauge streams — are a separate line, sitting in the gauge contract rather than the wallet. ## veCRV is locked, not liquid Locking CRV produces veCRV: non-transferable, time-locked for up to four years, decaying linearly toward the unlock date. This raises a genuine valuation question with no single right answer: - **Underlying value.** The locked CRV is still yours, eventually. Value it at the CRV price. - **Liquidity-adjusted.** It cannot be sold for up to four years. A four-year lock is not equivalent to spot CRV. Our view is that a portfolio API should report the underlying value and the unlock date, and leave the discount to the reporting layer — because the right discount depends on the fund's mandate, not on the chain. But the unlock date has to be in the data for that choice to be available at all. The same liquidity-classification argument applies to [restaked positions](/tracking-eigenlayer-restaking). ## Why this generalises Curve is a clear illustration of a pattern that recurs across DeFi: **the token in your wallet is a poor guide to where your capital is.** Gauges, vaults, escrow contracts and staking modules all move value one hop away from the address you are querying. The measured consequence is in [our benchmark](/crypto-portfolio-api-benchmark) — token-only APIs reported between $612.6k and $28.60M on a wallet worth $46.27M. ## Checking a provider For a wallet with LP staked in a gauge and CRV locked: - Does the staked LP position appear, or only unstaked LP tokens? - Are pending gauge rewards reported separately? - Is veCRV represented, with its unlock date? - Is the pool position resolved into underlying assets? A provider that only sees unstaked LP tokens will report a serious Curve user as holding almost nothing. --- # Try a Portfolio API Without an API Key > Authless lets you check any EVM portfolio and visualise transactions with no account, no key and no server-side storage — useful for evaluating coverage fast. - **URL:** https://octav.fi/blog/octav-authless-no-api-key - **Published:** 2026-02-01 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** API & Developers - **Tags:** authless, tooling, developers - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- The slowest part of evaluating a portfolio API is usually not the integration. It is getting a key: a signup, a sales call, a trial that starts before you have had time to test anything. [Octav Authless](https://authless.octav.fi) removes that step. Paste an EVM address, see the decoded portfolio and its transactions. No account, no key, no server-side storage of what you looked up. ## What it is for **Checking coverage before you commit.** The only evaluation that matters is whether an API sees what your wallets actually hold. Authless lets you run that test in a minute rather than a week — take an address you understand and see whether the lending, LP and staking positions appear. **Explaining a wallet to someone.** Sending a colleague a decoded portfolio view is more useful than a block explorer link, which shows transactions rather than positions. **Debugging.** When a portfolio number looks wrong in your own integration, Authless gives you an independent read of the same address without touching your key or your credit balance. ## What it is not It is not the product. Deliberately: | Authless | The [API](/crypto-portfolio-api-endpoint-reference) | | --- | --- | | EVM addresses | EVM, Solana, Hyperliquid | | A UI | JSON in your own systems | | No history | Historical and [snapshot](/daily-crypto-portfolio-snapshots) data | | No rate guarantees | 360 requests/minute, defined caching | | Nothing stored | Subscriptions, credits, sync status | If you are building on the data, you want the API. Authless exists to answer "is this worth integrating" honestly and quickly. ## The test worth running Take a wallet whose contents you can verify independently — ideally one with a lending position and something staked — and check three things: 1. Does the total match what you know is there? 2. Are protocol positions decoded, or only tokens listed? 3. Are the transactions labelled with protocol and action, or just hashes? Question 1 is the whole evaluation. The failure mode across this category is not an error, it is a plausible number missing a sector — the subject of [Why Portfolio APIs Disagree About Net Worth](/why-portfolio-apis-disagree). Then run the same wallet through a competitor. That is the exercise our [nine-provider benchmark](/crypto-portfolio-api-benchmark) automates, and you can reproduce a slice of it by hand in ten minutes. ## Where it sits Authless is one of several free, no-commitment entry points — alongside [Octav Perps](/perp-funding-rates-dashboard) for funding rates and the [protocols explorer](https://protocols.octav.fi) for coverage. The full map is in [Every Octav Tool and When to Use It](/octav-tools-overview). For the paid path and what it costs, see [How to Choose a Crypto Portfolio API](/choosing-a-crypto-portfolio-api). --- # Tracking EigenLayer Restaking Positions > Restaked assets leave your wallet, sit behind a withdrawal delay and carry slashing risk. What a portfolio system has to represent beyond a single value. - **URL:** https://octav.fi/blog/tracking-eigenlayer-restaking - **Published:** 2026-01-28 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Protocols - **Tags:** eigenlayer, restaking, defi - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Restaking takes an asset that was already productive and commits it again. For portfolio tracking, the awkward part is that the asset stops being in your wallet, stops being freely liquid, and acquires a risk that ordinary staking does not have. ## Where the asset goes Deposit an LST or native ETH into EigenLayer and the tokens leave your wallet for a strategy contract. A balance query on the address afterwards shows less than before, with no corresponding sale. That is the first failure mode: a provider without EigenLayer support does not report "restaked". It reports a smaller portfolio, and the difference looks like the assets were spent. ## What a complete representation contains | Field | Why it matters | | --- | --- | | Underlying asset and amount | The actual value at stake | | Operator delegated to | Concentration and counterparty risk | | AVSs secured | What the stake is exposed to | | Withdrawal status | Active, queued, or claimable | | Escrow completion time | When the capital is actually available | | Accrued rewards | Earned but possibly not yet claimable | Value alone answers none of the questions a risk or treasury function will ask. ## Liquidity is the real reporting problem A restaked position is not liquid. Withdrawing means entering a queue and waiting out an escrow period before the assets can be claimed. For a fund, that is a liquidity classification, not a footnote. A NAV that counts restaked ETH identically to spot ETH is arithmetically defensible and operationally misleading — the two cannot be sold on the same timeline. Any portfolio system feeding [NAV reporting](/what-is-crypto-nav-reporting) should preserve the distinction between liquid, queued and claimable. The three states are genuinely different: 1. **Active** — earning, withdrawable only by entering the queue. 2. **Queued** — no longer earning, not yet claimable, escrow running. 3. **Claimable** — escrow complete, awaiting a claim transaction. A position sitting in state 3 unnoticed is idle capital. ## Slashing is a real downside Restaking introduces slashing risk from the AVSs the stake secures. Unlike market risk, it is not captured by the asset's price. A portfolio number cannot express this on its own — which is precisely why the operator and AVS fields belong in the data. Two positions of identical value can carry very different exposure depending on what they are securing. ## Points and rewards Restaking programs frequently accrue points or rewards that are not yet transferable tokens. These are genuinely hard to value and easy to overstate. Our position is to keep them out of portfolio value until they are claimable tokens with a market. Booking an unclaimable, unpriced incentive as portfolio value is how a report becomes a projection. ## Layering with LSTs Restaked `wstETH` compounds the valuation chain: the wrapper's exchange rate (see [Valuing stETH and Liquid Staking](/valuing-steth-liquid-staking)), then the restaking layer on top. Get the first wrong and the second inherits the error. ## Checking a provider - Does restaked value appear at all, or does the portfolio just shrink? - Are queued withdrawals distinguished from active positions? - Is the operator exposed? - Are unclaimable points counted as value? They should not be. --- # Comparing Perp Funding Rates Across 9 DEXs > A free dashboard comparing funding rates for 320+ perpetual symbols across nine exchanges, with the spread, arbitrage view and how to read a funding table. - **URL:** https://octav.fi/blog/perp-funding-rates-dashboard - **Published:** 2026-01-23 - **Author:** Octav Team — Portfolio Intelligence for Digital Assets - **Topic:** Portfolio Management - **Tags:** perps, funding-rates, tooling - **Source:** Octav, Practical guides on crypto NAV reporting, multi-chain portfolio management and digital asset APIs, from the team behind Octav. --- Funding rates are the cost of holding a perpetual position, and they differ between venues for the same symbol — sometimes by a full percentage point. [Octav Perps](https://perpstats.octav.fi) is a free dashboard that puts every venue's rate for a symbol on one row so the spread is obvious. ![The Octav Perps funding rates dashboard comparing rates across nine exchanges](./images/perpstats-dashboard.jpg) ## What it covers | | | | --- | --- | | Exchanges | Apex, Aster, Binance, Bybit, Hyperliquid, Lighter, OKX, Pacifica, Paradex | | Symbols | 320+, including crypto, equities, FX and commodities perps | | Refresh | Every 60 seconds | | Views | Funding Rates · Arbitrage Opportunities · Simulation | | Price | Free, no account | The symbol list is broader than crypto. Perp venues now list equity and commodity synthetics — NVDA, TSLA, XAU, BRENTOIL — and those appear alongside BTC and ETH. ## How to read the table Each row is one symbol; each column is a venue. The three computed columns are where the value is: - **Best rate** — the most favourable funding available for your direction. - **Worst rate** — the least favourable. - **Spread** — the gap between them, which is the size of the opportunity. A positive funding rate means longs pay shorts. Negative means shorts pay longs. So "best" depends on which side you are on — a deeply negative rate is excellent if you are long and expensive if you are short. ## Why the spread exists Funding is a mechanism to keep a perp's price anchored to spot. Each venue computes it from its own order book, so the rate reflects positioning *on that venue*, not a global truth. Consequences worth internalising: 1. **Thin venues drift further.** A symbol with little open interest on a small venue can show a rate far from the majority. 2. **Rates are per-interval, not annualised.** A 0.01% rate charged every eight hours is roughly 10.9% a year. The table shows the interval rate. 3. **A wide spread is not free money.** Capturing it means holding offsetting positions on two venues, which costs margin on both, incurs fees, and carries liquidation risk on each leg independently. ## Funding is a portfolio line, not a footnote For anyone running perps at size, accrued funding is a real P&L component that does not appear in a token balance anywhere. It accrues inside the protocol, alongside margin and unrealised PnL. That is the same reason perp positions vanish from most portfolio trackers entirely — covered in [Tracking Hyperliquid Perps in Your Portfolio](/hyperliquid-perps-portfolio-tracking). If your portfolio system reports only deposited collateral, it is not capturing funding either, and a carry strategy will look flat while it is quietly earning or bleeding. ## Where this sits in the toolset Octav Perps is one of a set of free, standalone tools built on the same underlying data as the main platform — see [Every Octav Tool and When to Use It](/octav-tools-overview). If you want the funding and position data programmatically rather than in a dashboard, that is the [portfolio API](/crypto-portfolio-api-endpoint-reference).