From Moralis

If you’ve been calling the Moralis Web3 Data API for wallet balances, net worth, transaction history, PnL, DeFi positions, or token prices, the same data is available on Zerion API across 60+ EVM chains and Solana, usually in a single call. This guide shows the direct mapping for the main Moralis wallet endpoints, with copy-pasteable code for each. What you get with Zerion:

One address, all chains: Most Moralis endpoints take a single chain parameter per call, so a multi-chain read means one request per chain. Zerion returns every supported chain for an address in one call, filterable with filter[chain_ids].
One API for EVM and Solana: Moralis serves Solana from a separate base URL (solana-gateway.moralis.io) with a different response schema. Zerion accepts Solana addresses on the same /wallets/{address}/... endpoints used for EVM.
One call for tokens + DeFi: Moralis splits wallet tokens (/wallets/{address}/tokens) and DeFi positions (a separate API) into different products. Zerion serves both from /positions/?filter[positions]=no_filter.

Endpoint parity

Moralis paths below are relative to https://deep-index.moralis.io/api/v2.2 unless noted.

Use case	Moralis Web3 Data API	Zerion API
Tokens + DeFi (one call)	Two products (`/wallets/{address}/tokens` + DeFi positions)	`GET /v1/wallets/{address}/positions/?filter[positions]=no_filter`
Token balances (with prices)	`GET /wallets/{address}/tokens`	`GET /v1/wallets/{address}/positions/?filter[positions]=only_simple`
ERC-20 + native balance (legacy)	`GET /{address}/erc20` + `GET /{address}/balance`	Same `/positions/` call (native tokens included)
Net worth	`GET /wallets/{address}/net-worth`	`GET /v1/wallets/{address}/portfolio`
Net worth over time	(not available)	`GET /v1/wallets/{address}/charts/{period}`
Wallet history	`GET /wallets/{address}/history`	`GET /v1/wallets/{address}/transactions/`
Swaps only	`GET /wallets/{address}/swaps`	`GET /v1/wallets/{address}/transactions/?filter[operation_types]=trade`
Wallet PnL	`GET /wallets/{address}/profitability` (+ `/summary`)	`GET /v1/wallets/{address}/pnl`
DeFi positions	`GET https://api.moralis.com/v1/wallets/{address}/defi/positions`	`GET /v1/wallets/{address}/positions/?filter[positions]=only_complex`
Token price	`GET /erc20/{address}/price`	`GET /v1/fungibles/by-implementation?implementation={chain}:{address}`
Token metadata	`GET /erc20/metadata`	`GET /v1/fungibles/`
NFTs	`GET /{address}/nft`	`GET /v1/wallets/{address}/nft-positions/`
Solana wallet data	Separate Solana API (`solana-gateway.moralis.io`)	Same `/wallets/{address}/...` endpoints
Realtime updates	Moralis Streams	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 chains

The biggest structural change is how you address chains:

Moralis: Most endpoints take one chain query parameter per call (chain=eth, chain=0x1), so covering a wallet across five chains means five requests. Only net worth (and the newer Universal API endpoints) accept multiple chains at once.
Zerion: GET /v1/wallets/{address}/... returns every supported chain for the address by default, narrowed with filter[chain_ids]=ethereum,base. Chain IDs are full lowercase names (ethereum, not eth or 0x1); see the full list.

So a per-chain fan-out loop over chain=eth, chain=polygon, chain=base becomes a single Zerion call, with the chain of each row in relationships.chain.data.id.

Token balances

Moralis’s /wallets/{address}/tokens returns result[] with balance (raw integer), balance_formatted, usd_price, and usd_value per token, for one chain per call. Zerion returns a JSON:API collection covering all chains at once, with attributes.fungible_info for metadata, attributes.quantity for amounts, and attributes.value for USD values. 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

Moralis (`result[].…`)	Zerion (`data[].attributes.…`)
`token_address` (`native_token: true` for gas tokens)	`fungible_info.implementations[].address` (`null` for native)
`symbol`, `name`	`fungible_info.symbol`, `fungible_info.name`
`decimals`	`fungible_info.implementations[].decimals`
`logo`, `thumbnail`	`fungible_info.icon.url`
`balance` (raw integer string)	`quantity.int`
`balance_formatted`	`quantity.float` (decimal number). Also `quantity.numeric` (decimal string).
`usd_price`	`price`
`usd_price_24hr_percent_change`	`changes.percent_1d`
`usd_value`	`value` (USD, precomputed)
`usd_value_24hr_usd_change`	`changes.absolute_1d`
`portfolio_percentage`	Compute from `value` / `/portfolio` → `total.positions`
`possible_spam`	`flags.is_trash`, or filter server-side with `filter[trash]=only_non_trash`
`verified_contract`	`fungible_info.flags.verified`
`exclude_spam`, `exclude_unverified_contracts` (query)	`filter[trash]=only_non_trash` (query)
`total_supply`, `percentage_relative_to_total_supply`	Supply data lives on the asset: `/v1/fungibles/{id}` → `market_data.total_supply`, `market_data.circulating_supply`

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

If you’re on the legacy GET /{address}/erc20 + GET /{address}/balance pair, the same /positions/ call replaces both: native tokens come back as regular rows (implementation address: null), already decimal-adjusted and priced.

Net worth

Moralis’s net-worth returns total_networth_usd with a per-chain breakdown of native vs token value. Zerion’s /portfolio returns the total, the 24h change, a breakdown by chain, and a breakdown by position type (wallet, deposited, borrowed, locked, staked) in one response.

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

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

console.log(`Net worth: $${a.total.positions.toFixed(2)}`);
console.log(`24h change: $${a.changes.absolute_1d?.toFixed(2)} (${a.changes.percent_1d?.toFixed(2)}%)`);
console.log("By chain:", a.positions_distribution_by_chain);
console.log("By type:", a.positions_distribution_by_type);

import os, requests

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

res = requests.get(
    f"https://api.zerion.io/v1/wallets/{address}/portfolio",
    params={"currency": "usd"},
    auth=(api_key, ""),
)
a = res.json()["data"]["attributes"]
print(f"Net worth: ${a['total']['positions']:.2f}")
print(f"24h change: {a['changes']['percent_1d']}%")
print("By chain:", a["positions_distribution_by_chain"])
print("By type:", a["positions_distribution_by_type"])

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

Field mapping

Moralis (`net-worth`)	Zerion (`/portfolio` → `data.attributes.…`)
`total_networth_usd`	`total.positions`
`chains[].networth_usd`	`positions_distribution_by_chain` (keyed by chain ID)
`chains[].native_balance_usd` / `chains[].token_balance_usd`	No native-vs-token split. The breakdown is by position type instead: `positions_distribution_by_type` (`wallet`, `deposited`, `borrowed`, `locked`, `staked`).
(no equivalent)	`changes.absolute_1d`, `changes.percent_1d` (24h change)
(no equivalent on Moralis)	Net worth over time: `/wallets/{address}/charts/{period}` (periods from `hour` to `max`)

Wallet history

Moralis’s /wallets/{address}/history returns decoded transactions for one chain per call, with a category label, a summary sentence, and transfers split into erc20_transfers[], native_transfers[], and nft_transfers[]. Zerion’s /transactions/ returns enriched transactions across all chains at once, with a single decoded operation_type, one unified transfers[] array, 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

Moralis (`result[].…`)	Zerion (`data[].attributes.…`)
`hash`	`hash`
`block_timestamp` / `block_number`	`mined_at` (ISO 8601) / `mined_at_block`
`chain` (query param)	`relationships.chain.data.id` (per transaction)
`category` (`send`, `receive`, `token send`, `token receive`, `nft send`, `nft receive`, `airdrop`, `token swap`, `nft purchase`, `nft sale`, `deposit`, `withdraw`, `mint`, `burn`, `borrow`, `contract interaction`)	`operation_type` (`send`, `receive`, `trade`, `approve`, `revoke`, `deposit`, `withdraw`, `mint`, `burn`, `claim`, `bid`, `delegate`, `revoke_delegation`, `execute`, `deploy`). The send/receive variants collapse into `send` / `receive`; `token swap`, `nft purchase`, and `nft sale` become `trade`; `contract interaction` becomes `execute`. Approvals, which Moralis files under `contract interaction`, get their own `approve` / `revoke` types.
`summary` (human-readable sentence)	No direct equivalent. Compose from `operation_type` + `transfers[]`.
`erc20_transfers[]` / `native_transfers[]` / `nft_transfers[]` (three arrays)	One `transfers[]` array; each entry carries `fungible_info` or `nft_info`
transfer `value` / `value_formatted`	`transfers[].quantity.int` (raw) / `.float` (decimal). USD in `transfers[].value` (Moralis history has no USD values).
transfer `direction` (`send` / `receive`)	`transfers[].direction` (`out` / `in`)
transfer `from_address` / `to_address`	`transfers[].sender` / `transfers[].recipient`
`from_address` / `to_address` (transaction-level)	`sent_from` / `sent_to`
`from_address_label` / `to_address_label`	No direct equivalent. `relationships.dapp.data.id` names the dApp when Zerion recognizes the contract.
`method_label`	`application_metadata.method.name`
`transaction_fee` (native units)	`fee.quantity.float` (native) / `fee.value` (USD)
`receipt_status`	`status` (`confirmed` / `failed`, plus `pending` before mining)
`possible_spam`	`flags.is_trash`
`include_internal_transactions=true` + `internal_transaction` flag	Internal value movements already appear in `transfers[]`

Filter mapping

Moralis param	Zerion equivalent
`chain=eth` (one chain per call)	`filter[chain_ids]=ethereum` (comma-separated for multiple; omit for all chains)
`from_date` / `to_date`	`filter[min_mined_at]` / `filter[max_mined_at]` (ms epoch)
`limit=100`	`page[size]=100`
`cursor=<cursor>`	Follow `links.next` from the response
`order=DESC`	Default (newest first); ascending order is not supported
`/wallets/{address}/swaps`, `transactionTypes=buy,sell`	`filter[operation_types]=trade`, then read `transfers[].direction` to tell buys from sells

Wallet PnL

Moralis’s profitability endpoints return realized PnL only, per token (/profitability) or as totals (/profitability/summary), for one chain per call. Zerion’s /pnl returns wallet-level PnL computed with FIFO across all chains: 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

Moralis (`profitability` / `summary`)	Zerion (`data.attributes.…`)
`total_realized_profit_usd`	`realized_gain`
(not returned; realized only)	`unrealized_gain`
`total_realized_profit_percentage`	`relative_realized_gain_percentage`
`total_usd_invested` (per token)	`net_invested` (wallet-level)
`result[]` per-token rows (`avg_buy_price_usd`, `avg_sell_price_usd`, `realized_profit_usd`, `count_of_trades`)	Wallet-level totals. For a per-token breakdown, call `/pnl` with `filter[fungible_ids]` or `filter[fungible_implementations]`; average buy/sell prices are not returned.
`days=7/30/60/90/all`	`since` / `till` (ms epoch; pre-computed marks at 1 day, 1 week, 1 month, 1 year, year-to-date)
`chain=eth` (one chain; summary only on Ethereum, Base, Polygon)	All chains by default; narrow with `filter[chain_ids]`
(no equivalent)	`total_fee`, `received_external`, `sent_external`

See the wallet PnL tracker recipe for a worked example including per-token filtering.

DeFi positions

Moralis serves DeFi positions from its newer Universal API (api.moralis.com/v1), where each position nests a tokens[] array typed as supplied, borrowed, reward, or lp. Zerion flattens 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

Moralis (Universal API, `result[].…`)	Zerion (`data[].attributes.…`)
`protocolName` / `protocolId`	`protocol` / `relationships.dapp.data.id`
`protocolLogo`	`application_metadata.icon.url`
`chainId`	`relationships.chain.data.id`
`position.label` (`lending`, `liquidity`, `staking`, `farming`, `vault`, `yield`, `vesting`, `perps`, `other`)	`protocol_module` (`lending`, `liquidity_pool`, `staked`, `locked`, `rewards`, `vesting`, `deposit`, `investment`, `yield`)
`position.tokens[].tokenType` (`supplied` / `borrowed` / `reward` / `lp`)	`position_type` (`deposit`, `loan`, `reward`, `staked`, `locked`)
`position.tokens[].balanceFormatted`, `.usdPrice`, `.usdValue`	`quantity.float`, `price`, `value` (one row per token leg)
`position.balanceUsd`	Sum `value` over the position’s rows; wallet totals are in `/portfolio` → `positions_distribution_by_type`
`position.unclaimedUsd`	Rows with `position_type: reward`
`tokenType: lp` legs	One row per pool token, grouped by `group_id`
`positionDetails` (APY, health factor, shares)	No direct equivalent. Zerion surfaces the underlying token, USD value, and protocol module; derive health from supplied vs borrowed `value`.
`defi/summary` (`activeProtocols`, `totalUsd` per protocol)	Group rows by `relationships.dapp.data.id` and sum `value`

Moralis returns positions labeled perps. 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.

Token prices

Moralis’s /erc20/{address}/price returns a DEX-pair-derived price with exchange metadata, one token and one chain per call. 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

Moralis (price response)	Zerion (`data.attributes.…`)
`usdPrice` / `usdPriceFormatted`	`market_data.price`
`usdPrice24hrPercentChange`	`market_data.changes.percent_1d`
`nativePrice` (price in the chain’s gas token)	Request with `currency=eth` (the `currency` param accepts fiat and crypto units)
`tokenName`, `tokenSymbol`, `tokenLogo`, `tokenDecimals`	`name`, `symbol`, `icon.url`, `implementations[].decimals`
`exchangeName`, `pairAddress`, `pairTotalLiquidityUsd`	No direct equivalent. Zerion prices are aggregated, not tied to a single DEX pair.
`securityScore`, `possibleSpam`, `verifiedContract`	`flags.verified`
`to_block` (price at a block)	No direct equivalent. Use the fungible chart for a price timeseries.
`POST /erc20/prices` (batch, max 30)	One implementation per call. For a batch, page `/v1/fungibles/` and read `market_data.price` from each result.

If you also call GET /erc20/metadata, the same fungible objects carry the metadata: market_data.total_supply, market_data.circulating_supply, market_data.market_cap, and market_data.fully_diluted_valuation map to Moralis’s total_supply, circulating_supply, market_cap, and fully_diluted_valuation.

NFTs

Moralis’s GET /{address}/nft returns raw NFT holdings with tokenURI-based metadata for one chain per call. The Zerion equivalent is /v1/wallets/{address}/nft-positions/, which returns each holding with collection metadata and floor-price-based valuation across chains.

cURL

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

Moralis (`result[].…`)	Zerion (`data[].attributes.…`)
`token_address`	`nft_info.contract_address`
`token_id`	`nft_info.token_id`
`contract_type` (`ERC721` / `ERC1155`)	`nft_info.interface`
`name` / `metadata` / `normalized_metadata`	`nft_info.name`, `nft_info.content`
`amount` (quantity held)	`amount`
`floor_price` / `floor_price_usd` (with `include_prices=true`)	`price` (floor price) / `value` (floor value), returned by default
`possible_spam`	`nft_info.flags.is_spam`
`verified_collection`	No direct equivalent
`chain` (query param)	`relationships.chain.data.id`

Solana

Moralis serves Solana from a separate API (https://solana-gateway.moralis.io) with camelCase responses that don’t match the EVM schema. On Zerion, Solana addresses go through the same wallet endpoints as EVM and return the same shape:

Moralis Solana API	Zerion API
`GET /account/mainnet/{address}/portfolio`	`GET /v1/wallets/{address}/portfolio` + `/positions/`
`GET /account/mainnet/{address}/balance`	`/positions/` (native SOL comes back as a regular row)
`GET /account/mainnet/{address}/tokens`	`GET /v1/wallets/{address}/positions/?filter[chain_ids]=solana`
`GET /token/mainnet/{mint}/price`	`GET /v1/fungibles/by-implementation?implementation=solana:{mint}`
`GET /account/mainnet/{address}/nft`	`GET /v1/wallets/{address}/nft-positions/?filter[chain_ids]=solana`

Transaction history for Solana addresses works on the same /transactions/ endpoint. DeFi positions are not yet supported for Solana.

Pagination

Replace Moralis’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

Moralis Streams pushes on-chain events to your backend via webhooks. Zerion’s equivalent is 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 Moralis

Most Moralis wallet 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:

Price at a block and DEX-pair detail: Moralis prices accept to_block and return the source exchange, pair address, and pair liquidity. Zerion returns an aggregated live price plus a chart timeseries.
Per-token trade analytics: Moralis’s per-token PnL rows include average buy/sell prices and trade counts, and /swaps classifies each swap as a buy or sell. Zerion’s PnL is wallet-level (scopeable per token with filter[fungible_ids]), and trades are operation_type: trade transactions you classify from transfer directions.
Address labels: Moralis annotates transactions with from_address_label / to_address_label (exchanges, known entities). Zerion identifies dApps (relationships.dapp) but does not label counterparty addresses.
Token analytics signals: securityScore, pair liquidity, and holder data have no Zerion equivalent. Use filter[trash] and fungible_info.flags.verified for curation.
Perpetuals: Moralis DeFi positions include a perps label. Zerion does not return perpetuals as positions.
Bitcoin: Moralis Streams can watch Bitcoin addresses. Zerion covers EVM chains and Solana; check the supported chains list for the ones you rely on.

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

Authentication: Moralis uses an X-API-Key header. Zerion uses HTTP Basic Auth. Get a key at dashboard.zerion.io.
Chains: Moralis takes one chain per call (eth, 0x1). Zerion returns all supported chains by default and filters with full names: filter[chain_ids]=ethereum,base. See the note above.
One base URL: Moralis splits EVM (deep-index.moralis.io), Solana (solana-gateway.moralis.io), and the Universal API (api.moralis.com) across different hosts and schemas. Zerion serves everything from api.zerion.io/v1 with one response shape.
Consistent casing: Moralis mixes snake_case (wallet endpoints) and camelCase (prices, swaps, Solana, Universal API) across endpoint families. Zerion responses are uniformly snake_case JSON:API: payloads live under data[].attributes with related entities under data[].relationships.
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: Moralis nests typed tokens[] inside each position. Zerion returns one row per position leg 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.
USD values in history: Moralis history returns transfer amounts without USD values. Zerion returns value (USD at execution time) on each transfer and fee.
Wallet value over time: Moralis has no net-worth-history endpoint. Zerion’s /charts/{period} returns the wallet’s value timeseries directly.
Spam filtering: Moralis flags possible_spam and gates with exclude_spam / liquidity thresholds. Zerion uses filter[trash]=only_non_trash. See spam filtering.
Pagination: Moralis pages with a cursor 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 chains

Token balances

Field mapping

Net worth

Field mapping

Wallet history

Field mapping

Filter mapping

Wallet PnL

Field mapping

DeFi positions

Field mapping

Token prices

Field mapping

NFTs

Solana

Realtime updates

Differences from Moralis

Get in touch

​Endpoint parity

​A note on chains

​Token balances

​Field mapping

​Net worth

​Field mapping

​Wallet history

​Field mapping

​Filter mapping

​Wallet PnL

​Field mapping

​DeFi positions

​Field mapping

​Token prices

​Field mapping

​NFTs

​Solana

​Pagination

​Realtime updates

​Differences from Moralis

​Get in touch

Endpoint parity

A note on chains

Token balances

Field mapping

Net worth

Field mapping

Wallet history

Field mapping

Filter mapping

Wallet PnL

Field mapping

DeFi positions

Field mapping

Token prices

Field mapping

NFTs

Solana

Pagination

Realtime updates

Differences from Moralis

Get in touch