> ## Documentation Index
> Fetch the complete documentation index at: https://developers.zerion.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrate from DeBank Cloud to Zerion API

> A 1:1 mapping from the DeBank Cloud API to Zerion API, covering token balances, net worth, DeFi positions, wallet history, and NFTs with side-by-side code.

If you've been calling DeBank's Cloud API for token balances, net worth, DeFi portfolios, or wallet history, the same data is available on Zerion API across [60+ EVM chains and Solana](/supported-blockchains), often in a single call and with USD values precomputed.

This guide shows the direct mapping for the main DeBank user endpoints, with copy-pasteable code for each.

What you get with Zerion:

* **One call for tokens + DeFi:** Collapse DeBank's `all_token_list` and `all_complex_protocol_list` into a single `/positions/?filter[positions]=no_filter` response. `no_filter` can leave out a share token's own `wallet` row when a protocol position carries it as `receipt`. See [Deduplicating share tokens](/recipes/defi-positions#deduplicating-share-tokens) before you sum rows.
* **Solana on the same endpoints:** DeBank is EVM-only. Pass any EVM or Solana address to `/wallets/{address}/...` and get back the same enriched shape.
* **Values precomputed:** Zerion returns `value` (USD) per position and a portfolio breakdown by chain and by type (wallet, deposited, borrowed, locked, staked), so you don't multiply `amount` by `price` yourself.

## Endpoint parity

| Use case | DeBank Cloud API | Zerion API |
| - | - | - |
| Tokens + DeFi (one call) | Two requests (`all_token_list` + `all_complex_protocol_list`) | [`GET /v1/wallets/{address}/positions/?filter[positions]=no_filter`](/api-reference/wallets/get-wallet-fungible-positions) |
| Net worth + 24h change | `GET /v1/user/total_balance` | [`GET /v1/wallets/{address}/portfolio`](/api-reference/wallets/get-wallet-portfolio) |
| Net worth over time | `GET /v1/user/total_net_curve` | [`GET /v1/wallets/{address}/charts/{period}`](/api-reference/wallets/get-wallet-balance-chart) |
| Token balances | `GET /v1/user/all_token_list` (or `token_list` per chain) | [`GET /v1/wallets/{address}/positions/?filter[positions]=only_simple`](/api-reference/wallets/get-wallet-fungible-positions) |
| DeFi positions | `GET /v1/user/all_complex_protocol_list` | [`GET /v1/wallets/{address}/positions/?filter[positions]=only_complex`](/api-reference/wallets/get-wallet-fungible-positions) |
| Wallet history | `GET /v1/user/all_history_list` (or `history_list` per chain) | [`GET /v1/wallets/{address}/transactions/`](/api-reference/wallets/get-wallet-transactions) |
| NFTs | `GET /v1/user/all_nft_list` | [`GET /v1/wallets/{address}/nft-positions/`](/api-reference/wallets/get-wallet-nft-positions) |
| Chains used by a wallet | `GET /v1/user/used_chain_list` | Derive from `positions_distribution_by_chain` on [`/portfolio`](/api-reference/wallets/get-wallet-portfolio) |
| Real-time updates | (polling) | [Transaction webhooks](/webhooks) |

<Tip>
  Prefer not to write code? The [Zerion CLI](/build-with-ai/zerion-cli) wraps the same endpoints with a one-shot `npx @zerion/cli init` flow, useful for quick experiments and AI agents.
</Tip>

## Token balances

DeBank returns a flat array of token objects, where each token carries `amount` and `price` but no precomputed USD value (you multiply the two yourself). Zerion returns a JSON:API collection where each token is one entry under `data[]`, with `attributes.fungible_info` for metadata and `attributes.value` for the USD value already computed. The same endpoint accepts both EVM and Solana addresses.

<CodeGroup>
  ```javascript JavaScript (EVM) theme={null}
  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"}`);
  }
  ```

  ```javascript JavaScript (Solana) theme={null}
  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"}`);
  }
  ```

  ```python Python (EVM) theme={null}
  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}")
  ```

  ```python Python (Solana) theme={null}
  import os, requests

  api_key = os.environ["ZERION_API_KEY"]
  address = "6sEk1enayZBGFyNvvJMTP7qs5S3uC7KLrQWaEk38hSHH"

  res = requests.get(
      f"https://api.zerion.io/v1/wallets/{address}/positions/",
      params={
          "currency": "usd",
          "filter[chain_ids]": "solana",
          "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}")
  ```

  ```bash cURL (EVM) theme={null}
  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"
  ```

  ```bash cURL (Solana) theme={null}
  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"
  ```
</CodeGroup>

### Field mapping

| DeBank (token object) | Zerion (`data[].attributes.…`) |
| - | - |
| `symbol`, `display_symbol`, `optimized_symbol` | `fungible_info.symbol` |
| `name` | `fungible_info.name` |
| `decimals` | `fungible_info.implementations[].decimals` |
| `id` (contract address, or chain short name for native) | `fungible_info.implementations[].address` (`null` for native) |
| `chain` (short name, e.g. `eth`) | `relationships.chain.data.id` (full ID, e.g. `ethereum`) |
| `amount` (decimal) | `quantity.float` (decimal number). Also `quantity.int` (raw integer string) and `quantity.numeric` (decimal string). |
| `raw_amount` (raw integer) | `quantity.int` |
| `price` | `price` |
| `amount` × `price` (compute client-side) | `value` (USD, precomputed) |
| `logo_url` | `fungible_info.icon.url` |
| `is_verified` | `fungible_info.flags.verified` |
| `is_core`, `is_suspicious`, `credit_score`, `is_all=false` (curation signals) | `filter[trash]=only_non_trash` (request param) |
| `time_at` (first seen, unix) | No direct equivalent. `updated_at` (ISO 8601) reflects last balance update. |

<Note>
  `price` and `value` are `null` for tokens without a reliable price. Guard for `null` before summing or formatting.
</Note>

<Note>
  DeBank's token id for native gas tokens is the chain short name (for example `eth`, `matic`), not a contract address. Zerion returns `null` for the native token's implementation address. If you key tokens by their DeBank id, remap native tokens before comparing.
</Note>

## Net worth

DeBank's `total_balance` returns `total_usd_value` plus a per-chain breakdown. Zerion's [`/portfolio`](/api-reference/wallets/get-wallet-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.

<CodeGroup>
  ```javascript JavaScript theme={null}
  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);
  ```

  ```python Python theme={null}
  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"])
  ```

  ```bash cURL theme={null}
  curl -u "YOUR_API_KEY:" \
    "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/portfolio?currency=usd"
  ```
</CodeGroup>

### Field mapping

| DeBank (`total_balance`) | Zerion (`/portfolio` → `data.attributes.…`) |
| - | - |
| `total_usd_value` | `total.positions` |
| `chain_list[].usd_value` | `positions_distribution_by_chain` (keyed by chain ID) |
| (compute from token + protocol values) | `positions_distribution_by_type` (`wallet`, `deposited`, `borrowed`, `locked`, `staked`) |
| (no equivalent) | `changes.absolute_1d`, `changes.percent_1d` (24h change) |
| `total_net_curve` (separate endpoint) | [`/wallets/{address}/charts/{period}`](/api-reference/wallets/get-wallet-balance-chart) |

## DeFi positions

DeBank's `all_complex_protocol_list` returns protocols, each with a nested `portfolio_item_list[]` of positions split into `supply_token_list`, `borrow_token_list`, and `reward_token_list`. 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).

<CodeGroup>
  ```javascript JavaScript theme={null}
  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"}`);
  }
  ```

  ```python Python theme={null}
  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}")
  ```

  ```bash cURL theme={null}
  curl -g -u "YOUR_API_KEY:" \
    "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/positions/?currency=usd&filter[positions]=only_complex&sort=value"
  ```
</CodeGroup>

### Field mapping

| DeBank (protocol / `portfolio_item_list[]`) | Zerion (`data[].attributes.…`) |
| - | - |
| protocol `name`, `id` | `protocol`, `relationships.dapp.data.id` |
| protocol `logo_url` | `application_metadata.icon.url` |
| `portfolio_item_list[].name` (human label, e.g. `Lending`, `Liquidity Pool`) | `protocol_module` (`lending`, `staked`, `liquidity_pool`, `locked`, `rewards`, `vesting`, `deposit`, `investment`, `yield`) |
| `portfolio_item_list[].detail_types` (machine list, e.g. `["lending"]`, `["common"]`) | `position_type` (`deposit`, `loan`, `locked`, `staked`, `reward`, `investment`) |
| `detail.supply_token_list[]` | rows with `position_type: deposit` / `staked` |
| `detail.borrow_token_list[]` (present when the position has debt) | rows with `position_type: loan` |
| `detail.reward_token_list[]` | rows with `position_type: reward` |
| `detail.health_rate` (lending health factor) | No direct equivalent. Derive from supplied vs borrowed `value`. |
| token `amount` | `quantity.float` |
| token `price`, `amount` × `price` | `price`, `value` |
| `stats.asset_usd_value`, `stats.debt_usd_value`, `stats.net_usd_value` | Sum `value` per `position_type`; net worth split is in `/portfolio` → `positions_distribution_by_type` |
| `chain` | `relationships.chain.data.id` |

<Tip>
  **Borrowed-position exposure:** DeBank surfaces debt via `borrow_token_list` and `stats.debt_usd_value`. In Zerion, borrowed assets come back as positions with `position_type: loan`, and the wallet-level debt total is `positions_distribution_by_type.borrowed` on [`/portfolio`](/api-reference/wallets/get-wallet-portfolio).
</Tip>

## Wallet history

DeBank's `history_list` (per chain) and `all_history_list` (across chains) return transactions with `sends[]`, `receives[]`, and a `token_approve` block, where token references point into a separate `token_dict`. Zerion's [`/transactions/`](/api-reference/wallets/get-wallet-transactions) returns enriched, human-readable transactions with the token metadata inlined in each transfer, plus the dApp when Zerion recognizes it. The same endpoint accepts both EVM and Solana addresses.

<CodeGroup>
  ```javascript JavaScript (EVM) theme={null}
  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) ?? "?"}`);
  }
  ```

  ```python Python (EVM) theme={null}
  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}")
  ```

  ```bash cURL (EVM) theme={null}
  curl -g -u "YOUR_API_KEY:" \
    "https://api.zerion.io/v1/wallets/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/transactions/?currency=usd&page[size]=20"
  ```

  ```bash cURL (Solana) theme={null}
  curl -g -u "YOUR_API_KEY:" \
    "https://api.zerion.io/v1/wallets/6sEk1enayZBGFyNvvJMTP7qs5S3uC7KLrQWaEk38hSHH/transactions/?currency=usd&filter[chain_ids]=solana&page[size]=20"
  ```
</CodeGroup>

### Field mapping

| DeBank (`history_list[].…`) | Zerion (`data[].attributes.…`) |
| - | - |
| `id` (tx hash) | `hash` |
| `time_at` (unix) | `mined_at` (ISO 8601) / `mined_at_block` |
| `chain` (short name) | `relationships.chain.data.id` (full ID) |
| `cate_id` (coarse: `send`, `receive`, `approve`, or `null`) + `tx.name` (method name) | `operation_type` (always set: `send`, `receive`, `trade`, `approve`, `deposit`, `withdraw`, `mint`, `burn`, `claim`, `execute`, `deploy`) |
| `sends[]` / `receives[]` | `transfers[]` with `direction` (`out` / `in`) |
| `sends[].amount` / `receives[].amount` | `transfers[].quantity.float` (also `.int`, `.numeric`) |
| `sends[].to_addr` / `receives[].from_addr` | `transfers[].recipient` / `transfers[].sender` |
| `token_id` → look up in `token_dict` (an address, `eth` for native, or a non-address id for NFTs) | `transfers[].fungible_info` (inlined, no dictionary lookup) |
| `token_approve.spender`, `.value` | `operation_type: approve` with `acts[]` / `approvals` detail |
| `tx.from_addr` / `tx.to_addr` | `sent_from` / `sent_to` |
| `tx.usd_gas_fee` / `tx.eth_gas_fee` (present on wallet-initiated txs, not on incoming transfers) | `fee.value` / `fee.quantity.float` |
| `is_scam` (per-transaction flag) | `flags.is_trash` |
| `project_id` → `project_dict` | `relationships.dapp.data.id` (dApp slug, e.g. `uniswap-v3`) |
| `cex_id` → `cex_dict` | No direct equivalent (Zerion does not label CEX deposit addresses) |

### Filter mapping

| DeBank param | Zerion equivalent |
| - | - |
| `chain_id=eth` (single chain) | `filter[chain_ids]=ethereum` (comma-separated for multiple) |
| `token_id=0xa0b8…` (contract address) | `filter[fungible_ids]=<zerion-fungible-id>`. Zerion uses its own fungible IDs, not contract addresses. Look one up via [`/v1/fungibles?filter[search_query]=…`](/api-reference/fungibles/get-list-of-fungible-assets) or [`/v1/fungibles/{chain_id}:{address}`](/api-reference/fungibles/get-fungible-asset-by-implementation). |
| `start_time` (unix) | `filter[min_mined_at]` (and `filter[max_mined_at]`, ms epoch) |
| `page_count` (max 20) | `page[size]` |
| (paging cursor) | Follow `links.next` from the response |

## NFTs

DeBank's `all_nft_list` returns NFTs across chains. The Zerion equivalent is [`/v1/wallets/{address}/nft-positions/`](/api-reference/wallets/get-wallet-nft-positions), which returns each holding with collection metadata and floor-price-based valuation.

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

| DeBank (`nft_list[].…`) | Zerion (`data[].attributes.…`) |
| - | - |
| `contract_id` | `nft_info.contract_address` |
| `inner_id` | `nft_info.token_id` |
| `name` | `nft_info.name` |
| `collection_name` (flat string) | `collection_info.name` |
| `content` / `thumbnail_url` | `nft_info.content` |
| `attributes[]` (`trait_type` / `value`) | No direct equivalent (Zerion does not return a flat trait list) |
| `usd_price` (floor-based) | `value` (floor value); `price` is the floor price |
| `amount` (quantity held, for ERC-1155) | `amount` |
| `chain` | `relationships.chain.data.id` |

## Pagination

Replace DeBank's `start_time` cursor with Zerion's `links.next` URL. Each Zerion response includes a fully-formed next-page link you can fetch as-is.

```javascript theme={null}
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;
}
```

## Real-time updates

DeBank's Cloud API is request/response, so keeping a wallet fresh means polling. Zerion offers [transaction webhooks](/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](/recipes/wallet-activity-alerts) for a working example.

## Differences from DeBank

Most DeBank 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:**

* **Protocol- and pool-level data:** DeBank exposes protocol TVL, pool stats, and token-level analytics through its `/v1/protocol`, `/v1/pool`, and `/v1/token` endpoints. Zerion is wallet-centric and does not expose protocol or pool aggregates.
* **Long-tail chains:** DeBank indexes some chains Zerion doesn't yet cover. Check the [supported chains list](/supported-blockchains) for the ones you rely on before migrating.
* **CEX labeling in history:** DeBank tags known centralized-exchange deposit addresses via `cex_dict`. Zerion does not label CEX addresses.
* **Token first-seen timestamp:** DeBank's `time_at` (when a token first appeared) has no per-position equivalent; Zerion's `updated_at` reflects the last balance change, not first acquisition.

If any of these matter for your migration, [let us know](#get-in-touch). Your feedback helps shape our roadmap.

**Worth knowing:**

* **Authentication:** DeBank uses an `AccessKey` header. Zerion uses [HTTP Basic Auth](/authentication). Get a key at [dashboard.zerion.io](https://dashboard.zerion.io).
* **Solana:** DeBank is EVM-only. Zerion accepts Solana addresses on the same `/wallets/{address}/...` endpoints used for EVM, and returns the same enriched shape. DeFi positions are not yet supported for Solana.
* **Chain IDs:** DeBank uses lowercase short names (`eth`, `bsc`, `matic`, `arb`, `op`, `avax`). Zerion uses full string IDs (`ethereum`, `binance-smart-chain`, `polygon`, `arbitrum`, `optimism`, `avalanche`). See the [full list](/supported-blockchains).
* **Token IDs:** DeBank keys tokens by contract address (and the chain short name for native tokens). Zerion uses its own fungible IDs. Resolve one via [`/v1/fungibles/{chain_id}:{address}`](/api-reference/fungibles/get-fungible-asset-by-implementation).
* **Values precomputed:** DeBank token objects return `amount` and `price` but not a USD value; you multiply them. Zerion returns `value` 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). `no_filter` can leave out a share token's own `wallet` row when a protocol position carries it as `receipt`. See [Deduplicating share tokens](/recipes/defi-positions#deduplicating-share-tokens) before you sum rows.
* **Flattened DeFi:** DeBank nests positions under protocol objects with `supply`/`borrow`/`reward` token lists. Zerion returns one row per position tagged with `protocol_module` and `position_type` (including `loan` for debt). Reconstruct protocol grouping client-side via `relationships.dapp.data.id`.
* **No token dictionary:** DeBank history references tokens by id into a separate `token_dict`. Zerion inlines `fungible_info` in each transfer.
* **Transaction categorization:** DeBank's `cate_id` is coarse (`send`, `receive`, `approve`, or `null`), so most contract interactions arrive uncategorized and you infer intent from `tx.name` and `project_id`. Zerion always sets a decoded `operation_type` (`trade`, `deposit`, `withdraw`, `mint`, and so on).
* **Response shape:** Zerion uses [JSON:API](https://jsonapi.org/). Payloads live under `data[].attributes` with related entities under `data[].relationships`.
* **Spam filtering:** DeBank curates via `is_core`, `is_verified`, `is_suspicious`, `is_scam`, and `credit_score` signals (plus the `is_all` flag). Zerion uses `filter[trash]=only_non_trash`. See [spam filtering](/spam-filtering) for the full taxonomy.
* **Pagination:** DeBank pages history with `start_time`; Zerion returns a fully-formed `links.next` URL you can fetch as-is. See [pagination](/pagination-and-filtering).

## Get in touch

Have a use case we don't cover or need assistance with the migration? Our team can help. Reach out via the chat widget on [dashboard.zerion.io](https://dashboard.zerion.io), or [email us](mailto:api@zerion.io).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.