From Allium

If you’ve been calling Allium’s Realtime APIs for wallet balances, transactions, DeFi positions, PnL, or token prices, the same data is available on Zerion API across 60+ EVM chains and Solana, usually in a single call and with USD values precomputed. This guide shows the direct mapping for the main Allium Realtime endpoints, with copy-pasteable code for each. What you get with Zerion:

One address, all chains: Allium takes a {chain, address} pair per wallet, so a multi-chain balance read means one entry per chain. Zerion returns every supported chain for an address in one call to /wallets/{address}/positions/, filterable with filter[chain_ids].
One call for tokens + DeFi: Collapse Allium’s wallet/balances and wallet/positions into a single /positions/?filter[positions]=no_filter response.
Values precomputed: Allium balances return raw_balance (and a token.price you multiply yourself). Zerion returns quantity.float and value (USD) per position, plus a portfolio breakdown by chain and type.

Endpoint parity

Use case	Allium Realtime API	Zerion API
Tokens + DeFi (one call)	Two requests (`wallet/balances` + `wallet/positions`)	`GET /v1/wallets/{address}/positions/?filter[positions]=no_filter`
Token balances	`POST /api/v1/developer/wallet/balances`	`GET /v1/wallets/{address}/positions/?filter[positions]=only_simple`
DeFi positions	`POST /api/v1/developer/wallet/positions`	`GET /v1/wallets/{address}/positions/?filter[positions]=only_complex`
Transactions / activity	`POST /api/v1/developer/wallet/transactions`	`GET /v1/wallets/{address}/transactions/`
Holdings PnL	`POST /api/v1/developer/wallet/pnl`	`GET /v1/wallets/{address}/pnl`
Net worth + 24h change	(compute from holdings)	`GET /v1/wallets/{address}/portfolio`
Net worth over time	`wallet/balances/history` (per-token snapshots)	`GET /v1/wallets/{address}/charts/{period}`
Token price	`POST /api/v1/developer/prices`	`GET /v1/fungibles/by-implementation?implementation={chain}:{address}`
Token metadata / search	`tokens/list`, `tokens/search`	`GET /v1/fungibles/`
NFTs	(historical NFT trades)	`GET /v1/wallets/{address}/nft-positions/`
Multiple wallets in one call	Array body (1-100 wallets)	Wallet sets (`/v1/wallet-sets/...`)
Realtime updates	Streaming	Transaction webhooks

Prefer not to write code? The Zerion CLI wraps the same endpoints with a one-shot npx @zerion/cli init flow, useful for quick experiments and AI agents.

A note on request shape

The biggest structural change is how you address a wallet:

Allium: POST an array of {chain, address} objects. You pick the chain per wallet, and you can batch up to 100 wallets in one request.
Zerion: GET /v1/wallets/{address}/... with the address in the path. One address per call, all supported chains by default, narrowed with filter[chain_ids]. To read many wallets in one request, use the wallet sets endpoints.

So a single Allium call that fans out across [{ethereum, 0x…}, {polygon, 0x…}] for one wallet becomes a single Zerion call to that address (both chains already included), and a single Allium call across several different wallets becomes either N Zerion calls or one wallet-set call.

Token balances

Allium’s wallet/balances returns one item per token with raw_balance (an integer) and a token object that carries price but no precomputed USD value. Zerion returns a JSON:API collection where each token is one entry under data[], with attributes.fungible_info for metadata, attributes.quantity.float for the decimal-adjusted amount, and attributes.value for the USD value already computed. The same endpoint accepts both EVM and Solana addresses.

const API_KEY = process.env.ZERION_API_KEY;
const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";

const res = await fetch(
  `https://api.zerion.io/v1/wallets/${address}/positions/?currency=usd&filter[positions]=only_simple&filter[trash]=only_non_trash&sort=value`,
  {
    headers: {
      accept: "application/json",
      authorization: `Basic ${btoa(API_KEY + ":")}`,
    },
  }
);
const { data } = await res.json();

for (const pos of data) {
  const { fungible_info, quantity, price, value } = pos.attributes;
  const chain = pos.relationships.chain.data.id;
  console.log(`${fungible_info.symbol} on ${chain}: ${quantity.float} @ $${price} = $${value?.toFixed(2) ?? "N/A"}`);
}

const API_KEY = process.env.ZERION_API_KEY;
const address = "6sEk1enayZBGFyNvvJMTP7qs5S3uC7KLrQWaEk38hSHH";

const res = await fetch(
  `https://api.zerion.io/v1/wallets/${address}/positions/?currency=usd&filter[chain_ids]=solana&filter[trash]=only_non_trash&sort=value`,
  {
    headers: {
      accept: "application/json",
      authorization: `Basic ${btoa(API_KEY + ":")}`,
    },
  }
);
const { data } = await res.json();

for (const pos of data) {
  const { fungible_info, quantity, price, value } = pos.attributes;
  const chain = pos.relationships.chain.data.id;
  console.log(`${fungible_info.symbol} on ${chain}: ${quantity.float} @ $${price} = $${value?.toFixed(2) ?? "N/A"}`);
}

import os, requests

api_key = os.environ["ZERION_API_KEY"]
address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

res = requests.get(
    f"https://api.zerion.io/v1/wallets/{address}/positions/",
    params={
        "currency": "usd",
        "filter[positions]": "only_simple",
        "filter[trash]": "only_non_trash",
        "sort": "-value",
    },
    auth=(api_key, ""),
)
res.raise_for_status()

for pos in res.json()["data"]:
    info = pos["attributes"]["fungible_info"]
    qty = pos["attributes"]["quantity"]["float"]
    value = pos["attributes"]["value"]
    chain = pos["relationships"]["chain"]["data"]["id"]
    print(f"{info['symbol']} on {chain}: {qty} = ${value:.2f}" if value else f"{info['symbol']} on {chain}: {qty}")

curl -g -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/positions/?currency=usd&filter[positions]=only_simple&filter[trash]=only_non_trash&sort=value"

curl -g -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/6sEk1enayZBGFyNvvJMTP7qs5S3uC7KLrQWaEk38hSHH/positions/?currency=usd&filter[chain_ids]=solana&filter[trash]=only_non_trash&sort=value"

Field mapping

Allium (`items[].…`)	Zerion (`data[].attributes.…`)
`token.info.symbol`, `token.info.name`	`fungible_info.symbol`, `fungible_info.name`
`token.decimals`	`fungible_info.implementations[].decimals`
`token.address` (`native` type for gas tokens)	`fungible_info.implementations[].address` (`null` for native)
`chain`	`relationships.chain.data.id`
`raw_balance` / `raw_balance_str` (integer, not decimal-adjusted)	`quantity.int` (raw integer string). Also `quantity.float` (decimal number) and `quantity.numeric` (decimal string), so you don’t divide by `10^decimals` yourself.
`token.price`	`price`
`raw_balance / 10^decimals × token.price` (compute client-side)	`value` (USD, precomputed)
`token.attributes.total_liquidity_usd` (with `with_liquidity_info=true`)	No direct equivalent. Use `filter[trash]` for spam, and `fungible_info.flags.verified` for the curation signal.
`token.attributes.price_diff_pct_1d`	Available per asset via `/v1/fungibles/{id}` → `market_data.changes.percent_1d`
`block_timestamp`	`updated_at` (ISO 8601, last balance update)
(no equivalent)	`fungible_info.icon.url` (token logo, returned by default)

price and value are null for tokens without a reliable price. Guard for null before summing or formatting.

Transactions

Allium’s wallet/transactions returns transactions with asset_transfers[] (each tagged sent/received), a labels[] array, and an activities[] array describing what the transaction did (dex_trade, nft_trade, asset_approval, and so on). Zerion’s /transactions/ returns enriched, human-readable transactions with a single decoded operation_type, inlined transfer metadata, fees, and the dApp when Zerion recognizes it. The same endpoint accepts both EVM and Solana addresses.

const API_KEY = process.env.ZERION_API_KEY;
const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
const headers = {
  accept: "application/json",
  authorization: `Basic ${btoa(API_KEY + ":")}`,
};

const res = await fetch(
  `https://api.zerion.io/v1/wallets/${address}/transactions/?currency=usd&page[size]=20`,
  { headers }
);
const { data } = await res.json();

for (const tx of data) {
  const { operation_type, mined_at, transfers, fee } = tx.attributes;
  const chain = tx.relationships.chain.data.id;
  const dappId = tx.relationships.dapp?.data?.id;

  console.log(`[${mined_at}] ${operation_type} on ${chain}`);
  if (dappId) console.log(`  via ${dappId}`);
  for (const t of transfers) {
    const sign = t.direction === "out" ? "-" : "+";
    const symbol = t.fungible_info?.symbol ?? "NFT";
    console.log(`  ${sign}${t.quantity.float} ${symbol} ($${t.value?.toFixed(2) ?? "?"})`);
  }
  console.log(`  Fee: $${fee.value?.toFixed(2) ?? "?"}`);
}

import os, requests

api_key = os.environ["ZERION_API_KEY"]
address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

res = requests.get(
    f"https://api.zerion.io/v1/wallets/{address}/transactions/",
    params={"currency": "usd", "page[size]": 20},
    auth=(api_key, ""),
)
for tx in res.json()["data"]:
    attrs = tx["attributes"]
    chain = tx["relationships"]["chain"]["data"]["id"]
    dapp_id = (tx["relationships"].get("dapp") or {}).get("data", {}).get("id")
    print(f"[{attrs['mined_at']}] {attrs['operation_type']} on {chain}")
    if dapp_id:
        print(f"  via {dapp_id}")
    for t in attrs["transfers"]:
        sign = "-" if t["direction"] == "out" else "+"
        symbol = (t.get("fungible_info") or {}).get("symbol", "NFT")
        val = t.get("value")
        print(f"  {sign}{t['quantity']['float']} {symbol} (${val:.2f})" if val else f"  {sign}{t['quantity']['float']} {symbol}")

curl -g -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/transactions/?currency=usd&page[size]=20"

curl -g -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/6sEk1enayZBGFyNvvJMTP7qs5S3uC7KLrQWaEk38hSHH/transactions/?currency=usd&filter[chain_ids]=solana&page[size]=20"

Field mapping

Allium (`items[].…`)	Zerion (`data[].attributes.…`)
`hash`	`hash`
`block_timestamp`	`mined_at` (ISO 8601) / `mined_at_block`
`chain`	`relationships.chain.data.id`
`labels[]` (coarse tags, e.g. `transfer`) + `activities[].type` (richer DeFi actions: `dex_trade`, `nft_trade`, `asset_approval`, `asset_bridge`, …)	`operation_type` (`trade`, `send`, `receive`, `approve`, `revoke`, `deposit`, `withdraw`, `mint`, `burn`, `claim`, `bid`, `delegate`, `revoke_delegation`, `execute`, `deploy`). Zerion folds Allium’s classification into one decoded field; `activities[]` is empty for plain transfers, where the tag sits in `labels[]`.
`type` (numeric EVM envelope type, e.g. `2` for EIP-1559)	No equivalent. This is the raw transaction type, not a semantic category; Zerion does not expose it.
`asset_transfers[].transfer_type` (`sent` / `received`)	`transfers[].direction` (`out` / `in`)
`asset_transfers[].asset.type` (`native`, `evm_erc20`, `evm_erc721`, `evm_erc1155`)	`transfers[].fungible_info` vs `transfers[].nft_info`
`asset_transfers[].asset.symbol`, `.decimals`	`transfers[].fungible_info.symbol`, `.implementations[].decimals`
`asset_transfers[].amount.raw_amount` / `.amount`	`transfers[].quantity.int` (raw) / `.float` (decimal). USD in `transfers[].value`.
`asset_transfers[].from_address` / `.to_address`	`transfers[].sender` / `transfers[].recipient`
`from_address` / `to_address` (transaction-level)	`sent_from` / `sent_to`
`fee.amount` / `fee.raw_amount`	`fee.value` (USD) / `fee.quantity.float`
(no equivalent)	`relationships.dapp.data.id` (dApp slug, e.g. `uniswap-v3`, present when Zerion identifies it)

Filter mapping

Allium param	Zerion equivalent
`activity_type=dex_trade`	`filter[operation_types]=trade` (comma-separated for multiple)
`transaction_hash=0x…`	`filter[search_query]=0x…`
`limit=100`	`page[size]=100`
`cursor=<cursor>`	Follow `links.next` from the response
(chain set per wallet in the body)	`filter[chain_ids]=ethereum,base`

DeFi positions

Allium’s wallet/positions returns typed positions, where the field set depends on position_type (LP, lending, staked, regular, perp, vault). Lending positions nest supplies[], borrows[], and collateral[]; LP positions carry token0/token1; staked positions carry staked_token and rewards_token. Zerion flattens all of this: each position is one row under /positions/?filter[positions]=only_complex, tagged with protocol, protocol_module, and position_type (including loan for borrowed assets).

const API_KEY = process.env.ZERION_API_KEY;
const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";

const res = await fetch(
  `https://api.zerion.io/v1/wallets/${address}/positions/?currency=usd&filter[positions]=only_complex&sort=value`,
  { headers: { accept: "application/json", authorization: `Basic ${btoa(API_KEY + ":")}` } }
);
const { data } = await res.json();

for (const pos of data) {
  const { name, protocol, protocol_module, position_type, quantity, value } = pos.attributes;
  const chain = pos.relationships.chain.data.id;
  console.log(`[${position_type}] ${name} | ${protocol} (${protocol_module}) on ${chain}: ${quantity.float} = $${value?.toFixed(2) ?? "N/A"}`);
}

import os, requests

api_key = os.environ["ZERION_API_KEY"]
address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

res = requests.get(
    f"https://api.zerion.io/v1/wallets/{address}/positions/",
    params={"currency": "usd", "filter[positions]": "only_complex", "sort": "-value"},
    auth=(api_key, ""),
)
for pos in res.json()["data"]:
    a = pos["attributes"]
    chain = pos["relationships"]["chain"]["data"]["id"]
    print(f"[{a.get('position_type')}] {a['name']} | {a.get('protocol')} ({a.get('protocol_module')}) on {chain}: {a['quantity']['float']} = ${a['value'] or 0:.2f}")

curl -g -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/positions/?currency=usd&filter[positions]=only_complex&sort=value"

Field mapping

Allium (`items[].…`)	Zerion (`data[].attributes.…`)
`protocol`	`protocol` (plus `relationships.dapp.data.id` for the slug)
`position_type` (`LP`, `lending`, `staked`, `perp`, `vault`)	`protocol_module` (`lending`, `staked`, `liquidity_pool`, `locked`, `rewards`, `vesting`, `deposit`, `investment`, `yield`) + `position_type` (`deposit`, `loan`, `staked`, `reward`, `locked`)
`total_value_usd`	`value` (per row). Wallet-level totals are in `/portfolio` → `positions_distribution_by_type`.
`supplies[]` / `collateral[]`	rows with `position_type: deposit` / `staked`
`borrows[]`	rows with `position_type: loan`
`staked_amount`, `unclaimed_rewards`	rows with `position_type: staked` / `reward`
`token0` / `token1` (LP pair)	one row per pool token, grouped by `group_id` (see positions)
`health_factor`	No direct equivalent. Derive from supplied vs borrowed `value`.
`apy`, `fee_tier`, `in_range`, `unclaimed_fees_*`	No direct equivalent. Zerion surfaces the position’s underlying token, USD value, and protocol module.
`chain`	`relationships.chain.data.id`
(no equivalent)	`application_metadata.name` / `application_metadata.icon.url` (protocol display name + logo)

Allium returns dedicated perp positions (size, entry/mark price, leverage, liquidation price, unrealized PnL). Zerion’s positions model is spot and DeFi-protocol oriented and does not return perpetuals as positions. If perps matter for your migration, let us know.

Holdings PnL

Allium’s wallet/pnl returns per-token PnL (realized_pnl, unrealized_pnl, average_cost) plus wallet totals. Zerion’s /pnl returns wallet-level PnL computed with FIFO: realized and unrealized gain, net invested, total fees, and external in/out flows.

const API_KEY = process.env.ZERION_API_KEY;
const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";

const res = await fetch(
  `https://api.zerion.io/v1/wallets/${address}/pnl?currency=usd`,
  { headers: { accept: "application/json", authorization: `Basic ${btoa(API_KEY + ":")}` } }
);
const { data } = await res.json();
const a = data.attributes;

console.log(`Realized gain:   $${a.realized_gain?.toFixed(2)}`);
console.log(`Unrealized gain: $${a.unrealized_gain?.toFixed(2)}`);
console.log(`Net invested:    $${a.net_invested?.toFixed(2)}`);
console.log(`Total fees:      $${a.total_fee?.toFixed(2)}`);

import os, requests

api_key = os.environ["ZERION_API_KEY"]
address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

res = requests.get(
    f"https://api.zerion.io/v1/wallets/{address}/pnl",
    params={"currency": "usd"},
    auth=(api_key, ""),
)
a = res.json()["data"]["attributes"]
print(f"Realized gain:   ${a['realized_gain']:.2f}")
print(f"Unrealized gain: ${a['unrealized_gain']:.2f}")
print(f"Net invested:    ${a['net_invested']:.2f}")
print(f"Total fees:      ${a['total_fee']:.2f}")

curl -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/pnl?currency=usd"

Field mapping

Allium (`items[].…`)	Zerion (`data.attributes.…`)
`total_realized_pnl.amount`	`realized_gain`
`total_unrealized_pnl.amount`	`unrealized_gain`
`total_balance.amount`	Current value via `/portfolio` → `total.positions`
`tokens[].average_cost`	No wallet-summary equivalent. Per-token cost basis is reflected in `net_invested` / `realized_cost_basis`.
`tokens[].realized_pnl` / `.unrealized_pnl` (per token)	Wallet-level `realized_gain` / `unrealized_gain`. For a per-token breakdown, filter with `filter[fungible_ids]` or `filter[fungible_implementations]`.
`min_liquidity` (query)	No direct equivalent. Assets without prices are excluded automatically and reported in `meta`.
(no equivalent)	`net_invested`, `total_fee`, `received_external`, `sent_external`

Allium’s wallet/pnl accepts a batch of wallets and returns per-token rows. To replicate a per-token breakdown on Zerion, call /pnl with filter[fungible_ids]=…. See the wallet PnL tracker recipe for a worked example.

Token prices

Allium’s prices endpoint takes a batch of {token_address, chain} objects and returns the latest price with OHLC. Zerion resolves a token by its implementation and returns full asset metadata including market_data.price and recent changes.

const API_KEY = process.env.ZERION_API_KEY;
const implementation = "ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"; // USDC

const res = await fetch(
  `https://api.zerion.io/v1/fungibles/by-implementation?implementation=${implementation}&currency=usd`,
  { headers: { accept: "application/json", authorization: `Basic ${btoa(API_KEY + ":")}` } }
);
const { data } = await res.json();
const m = data.attributes.market_data;

console.log(`${data.attributes.symbol}: $${m.price}`);
console.log(`24h change: ${m.changes?.percent_1d?.toFixed(2)}%`);

import os, requests

api_key = os.environ["ZERION_API_KEY"]
implementation = "ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"  # USDC

res = requests.get(
    "https://api.zerion.io/v1/fungibles/by-implementation",
    params={"implementation": implementation, "currency": "usd"},
    auth=(api_key, ""),
)
a = res.json()["data"]["attributes"]
m = a["market_data"]
print(f"{a['symbol']}: ${m['price']}")
print(f"24h change: {m['changes']['percent_1d']}%")

curl -u "YOUR_API_KEY:" \
  "https://api.zerion.io/v1/fungibles/by-implementation?implementation=ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&currency=usd"

Field mapping

Allium (`items[].…`)	Zerion (`data.attributes.…`)
`price`	`market_data.price`
`open` / `high` / `low` / `close`	No direct equivalent for the latest interval. Use the fungible chart for a price timeseries.
`timestamp`	`market_data.price` is the live value; chart points carry timestamps.
`decimals`	`implementations[].decimals`
(one request per implementation)	One implementation per call. For a list, page `/v1/fungibles/` with `filter[implementation_address]`.

Allium’s prices endpoint batches up to 200 tokens per request. Zerion’s by-implementation resolves one token per call. For a batch, query /v1/fungibles/ and read market_data.price from each result, or cache the Zerion fungible_id per token and reuse it.

Pagination

Replace Allium’s cursor query parameter with Zerion’s links.next URL. Each Zerion response includes a fully-formed next-page link you can fetch as-is.

async function getAll(url) {
  const all = [];
  const headers = { accept: "application/json", authorization: `Basic ${btoa(API_KEY + ":")}` };

  while (url) {
    const res = await fetch(url, { headers });
    const { data, links } = await res.json();
    all.push(...data);
    url = links?.next ?? null;
  }
  return all;
}

Realtime updates

Allium offers a streaming product for low-latency blockchain data. Zerion offers transaction webhooks: subscribe a callback URL to one or more wallets and receive a POST when any of them transact. See the wallet activity alerts recipe for a working example.

Differences from Allium

Most Allium Realtime use cases have a direct Zerion equivalent. A few aren’t covered, and others behave differently. Worth a scan before you cut over. Not supported today:

Non-EVM, non-Solana chains: Allium Realtime covers chains like Bitcoin, Stellar, NEAR, and Sui. Zerion covers EVM chains and Solana. Check the supported chains list for the ones you rely on.
Perpetuals: Allium returns perp positions with leverage, mark price, and liquidation price. Zerion’s positions model does not return perpetuals.
Per-token historical balance snapshots: Allium’s wallet/balances/history returns point-in-time token balances. Zerion exposes wallet value over time via /charts/{period} and asset price history via the fungible chart, but not a per-token balance-at-timestamp endpoint.
OHLC price candles: Allium’s prices endpoint returns open/high/low/close per interval. Zerion returns live price plus a chart timeseries, not OHLC candles.
Liquidity and holder analytics: Allium exposes total_liquidity_usd and holders_count on tokens. Zerion does not return pool liquidity or holder counts.

If any of these matter for your migration, let us know. Your feedback helps shape our roadmap. Worth knowing:

Authentication: Allium uses an X-API-KEY header. Zerion uses HTTP Basic Auth. Get a key at dashboard.zerion.io.
Request shape: Allium endpoints are POST with a JSON array of {chain, address} objects. Zerion endpoints are GET /v1/wallets/{address}/... with the address in the path. See the note above.
One address spans all chains: Allium pairs each address with one chain. Zerion returns every supported chain for an address by default, narrowed with filter[chain_ids].
Multiple wallets: Allium batches up to 100 wallets per call. Zerion reads one address per /wallets/ call; for batches use the wallet sets endpoints.
Values precomputed: Allium balances return raw_balance and a token.price; you divide by 10^decimals and multiply. Zerion returns quantity.float and value (USD) per position.
One endpoint for tokens and DeFi: Zerion serves both wallet tokens and DeFi positions from /positions/. Switch via filter[positions]=only_simple (wallet only), only_complex (DeFi only), or no_filter (both).
Flattened DeFi: Allium returns typed positions with nested supplies/borrows/collateral. Zerion returns one row per position tagged with protocol_module and position_type (including loan for debt). Group by relationships.dapp.data.id to reconstruct protocols, and by group_id to reconstruct LP pairs.
Chain IDs: Allium and Zerion both use lowercase string chain IDs (e.g. ethereum, solana), so most map 1:1. Confirm the longer-tail names against the full list.
Response shape: Zerion uses JSON:API. Payloads live under data[].attributes with related entities under data[].relationships.
Spam filtering: Allium gates dust with min_liquidity / with_liquidity_info. Zerion uses filter[trash]=only_non_trash. See spam filtering for the full taxonomy.
Pagination: Allium pages with a cursor query parameter; Zerion returns a fully-formed links.next URL you can fetch as-is. See pagination.

Get in touch

Have a use case we don’t cover or need assistance with the migration? Our team is happy to help! Reach out via the chat widget on dashboard.zerion.io, or email us.

Get Started

Core Concepts

Migrating to Zerion API

Endpoint parity

A note on request shape

Token balances

Field mapping

Transactions

Field mapping

Filter mapping

DeFi positions

Field mapping

Holdings PnL

Field mapping

Token prices

Field mapping

Realtime updates

Differences from Allium

Get in touch

​Endpoint parity

​A note on request shape

​Token balances

​Field mapping

​Transactions

​Field mapping

​Filter mapping

​DeFi positions

​Field mapping

​Holdings PnL

​Field mapping

​Token prices

​Field mapping

​Pagination

​Realtime updates

​Differences from Allium

​Get in touch

Endpoint parity

A note on request shape

Token balances

Field mapping

Transactions

Field mapping

Filter mapping

DeFi positions

Field mapping

Holdings PnL

Field mapping

Token prices

Field mapping

Pagination

Realtime updates

Differences from Allium

Get in touch