Etherscan API alternatives: GoldRush vs Etherscan, side by side

Covalent TeamUpdated 11 min read

What the Etherscan API V2 covers, its limits and pricing, how GoldRush compares with the same call made both ways, and the other Etherscan API alternatives.

The best Etherscan API alternative depends on why you are leaving. If you need wallet data across many chains, decoded and priced in one call, a multichain data API such as the GoldRush Foundational API fits: one request returns an address's native and ERC-20 balances with fiat values, where Etherscan needs a paid plan for the same list. If you want a drop-in replacement for Etherscan's module/action calls, an explorer API such as Blockscout's is closer. If you need contract verification, verified source code or ABIs, stay with Etherscan: GoldRush doesn't offer those.

This guide sets out what the Etherscan API V2 covers and costs, compares it with GoldRush row by row, makes the same call both ways, and lists the other alternatives.

Checked on 20 November 2026 against Etherscan's API plans page and API documentation. Etherscan changes its plans and chain list often, so check them before you commit.

What the Etherscan API offers

Etherscan is the best-known Ethereum block explorer, and its API serves the data behind its pages. Version 2 of the API, the current one, puts every supported chain behind one key and one base URL, https://api.etherscan.io/v2/api. You pick the chain with a chainid parameter and the endpoint with module and action, and send your key as an apikey query parameter (Make your first call).

  • Chains. 57 EVM chains, 30 mainnets and 27 testnets, according to its supported chains page. 46 of them are on the free tier and 11 need a paid plan, among them BNB Smart Chain, Base, OP Mainnet, Avalanche C-Chain and Gnosis.
  • Accounts. Native balances, normal, internal and beacon-withdrawal transactions, and ERC-20, ERC-721 and ERC-1155 transfers for an address (endpoint overview).
  • Contracts. Verified source code and ABIs (free on every chain and plan), contract creators, and source code verification for Solidity, Vyper, Stylus and zkSync contracts.
  • Logs, blocks and gas. Event logs by address and topics, block rewards and block-by-timestamp, a gas oracle, and a proxy module for eth_* calls such as eth_call and eth_getTransactionReceipt.
  • PRO endpoints (Standard plan and up): every ERC-20 or ERC-721 token an address holds, historical balances at a block, token holder lists and counts, token info, historical ETH prices and the daily network statistics.
  • Address labels. Name tags and metadata for an address need the Pro Plus plan.

Responses share one envelope: status ("1" or "0"), message and result. Amounts are strings in the token's smallest unit, so you divide by 10^decimals yourself.

Etherscan API limits and pricing

Plan Price per month Rate limit Calls per day What it adds
Free $0 3 calls/second 100,000 Selected chains only, no PRO endpoints
Lite $49 5 calls/second 100,000 All supported chains
Standard $199 10 calls/second 200,000 PRO endpoints
Advanced $299 20 calls/second 500,000 Commercial use
Professional $399 30 calls/second 1,000,000
Pro Plus $899 30 calls/second 1,500,000 Address metadata endpoint, one app license
Dedicated Contact sales Unmetered Unmetered Dedicated infrastructure and an SLA

Monthly prices from etherscan.io/apis, with discounts for quarterly and yearly billing; rate limits from Etherscan's rate limits page. Three limits matter most when you compare:

  • Commercial use starts at Advanced. Etherscan labels Free, Lite and Standard "Personal & Research use", and its FAQ says customers with Advanced or higher plans may use the API in their own applications.
  • Daily caps are hard. Since 3 November 2026, requests are blocked once you reach your plan's daily limit. Paid plans can turn on overage at $3 per 100,000 calls; the free tier can't.
  • The wallet-wide token list is PRO and throttled. The endpoint that returns every ERC-20 an address holds (addresstokenbalance) needs the Standard plan and is limited to 2 calls per second on any plan. On the free tier you read one token at a time with tokenbalance, so you need to know the contract addresses first.

Why developers look for an Etherscan API alternative

The old reason, that Etherscan covered only Ethereum, no longer holds: V2 covers many EVM chains with one key. The reasons teams look elsewhere now are these:

  • Ready-to-use data. Etherscan returns explorer records: raw amounts, raw input data, and one token's balance per free call. Apps that show wallets, portfolios or tax reports need balances with prices, logos and spam flags, and transactions with decoded events.
  • Fewer calls per screen. A wallet view on Etherscan is a native balance call, a token holdings call (PRO) and a call per chain. A data API can return the native and token balances in one call, and several chains in one more.
  • Chains Etherscan doesn't cover. Its list is EVM only, and some chains your users hold assets on may be missing or paid-only.
  • Pricing that follows usage. Etherscan prices by rate limit and daily cap per plan. Credit-based APIs charge per call or per item returned.

GoldRush vs Etherscan API, side by side

GoldRush is a multichain blockchain data API: REST endpoints that return balances, transactions, transfers, NFTs, holders and prices, decoded and priced, under one key. It isn't a block explorer, and it doesn't do contract verification.

Etherscan API V2 GoldRush Foundational API
Chains 57 EVM chains (30 mainnets); 11 need a paid plan EVM chains plus Bitcoin; see supported chains
Request style One URL; chainid, module and action parameters; key in the query string One REST path per endpoint with the chain name in it (eth-mainnet); key in an Authorization: Bearer header
Every token an address holds PRO (Standard, $199/month and up), ERC-20 only, 2 calls/second; native balance separate Token balances: native and ERC-20 in one call, with fiat values and a spam flag (1 per call)
Balances on several chains at once One request per chainid Multichain balances for one address across EVM chains (2.5 per call)
Transaction history Free, with raw input data and the function name Transactions with decoded log events (0.1 per item)
ERC-20 transfers Free Token transfers with the token's price on the day (0.05 per item)
Token holders PRO, current holders Token holders at any block height, on 16 chains (0.02 per item)
Contract verification, source, ABI Yes, free on every chain Not offered
Pricing Free tier, then $49 to $899 a month by rate limit and daily cap; commercial use from $299 Credits per call or per item, as listed for each endpoint; free trial, then the plans on the pricing page

GoldRush credit costs are the base rates from each endpoint's docs page. The pricing calculator estimates a month of calls.

The same call both ways: token balances for an address

Here is one task, done with each API: list the native token and every ERC-20 an address holds on Ethereum, with a USD value where the API gives one. Both functions return the same shape, so you can swap one for the other. They need Node.js 18 or later, for the built-in fetch.

With Etherscan, it takes two endpoints: balance for the native token, and addresstokenbalance (PRO, Standard plan and up) for the ERC-20 tokens, paged and throttled to 2 calls per second:

const ETHERSCAN = "https://api.etherscan.io/v2/api";const units = (raw, decimals) => Number(raw) / 10 ** decimals;const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); async function etherscan(params) {    const query = new URLSearchParams({ ...params, apikey: process.env.ETHERSCAN_API_KEY });    const res = await fetch(`${ETHERSCAN}?${query}`);    const body = await res.json();    if (body.status === "1") return body.result;    // "0" is an error, or a valid request that found no records.    if (Array.isArray(body.result) && body.result.length === 0) return [];    throw new Error(`${body.message}: ${body.result}`);} async function balancesFromEtherscan(chainId, address) {    const native = await etherscan({ chainid: chainId, module: "account", action: "balance", address, tag: "latest" });    const tokens = [];    for (let page = 1; ; page++) {        await sleep(500); // addresstokenbalance allows 2 calls per second on every plan        const batch = await etherscan({            chainid: chainId,            module: "account",            action: "addresstokenbalance",            address,            page,            offset: 100,        });        tokens.push(...batch);        if (batch.length < 100) break;    }    return [        // The native balance comes back in wei; Etherscan gives no USD value for it here.        { symbol: "native", contract: null, amount: units(native, 18), usd: null },        ...tokens.map((t) => {            const amount = units(t.TokenQuantity, Number(t.TokenDivisor));            return { symbol: t.TokenSymbol, contract: t.TokenAddress, amount, usd: amount * Number(t.TokenPriceUSD) };        }),    ];}

With GoldRush, it is one call to token balances (balances_v2), which returns the native token alongside the ERC-20s, each with its value in the quote currency. no-spam=true drops tokens flagged as spam, on Foundational chains:

const GOLDRUSH = "https://api.covalenthq.com/v1";const headers = { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` }; async function balancesFromGoldRush(chainName, address) {    const url = `${GOLDRUSH}/${chainName}/address/${address}/balances_v2/?quote-currency=USD&no-spam=true`;    const res = await fetch(url, { headers });    if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);    const { data } = await res.json();    return data.items.map((t) => ({        symbol: t.contract_ticker_symbol,        contract: t.is_native_token ? null : t.contract_address,        amount: Number(t.balance) / 10 ** t.contract_decimals,        usd: t.quote,    }));}

Call either one the same way:

const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"; console.table(await balancesFromEtherscan(1, address)); // chain IDconsole.table(await balancesFromGoldRush("eth-mainnet", address)); // chain name

What differs:

  • Calls and plan. Etherscan makes at least two calls, one of them a PRO endpoint; GoldRush makes one, at 1 per call.
  • Spam. Etherscan's response has no spam flag, so airdropped junk tokens come back with the rest (its own example response includes one priced at zero). GoldRush flags them with is_spam and can drop them.
  • More chains. For Etherscan, run the function once per chain ID. For GoldRush, the multichain balances endpoint (/v1/allchains/address/{address}/balances/) returns one address's balances on several EVM chains in one paged call.
  • Amounts. Both convert raw units with Number, which is fine for display. Keep the raw strings as BigInt if you do accounting.

Other Etherscan API alternatives

Each of these answers a different reason for leaving Etherscan:

  • Blockscout. An open-source explorer whose API keeps Etherscan's module/action style, so it is the closest to a drop-in swap. Its migration guide says you change the base URL, use chain_id instead of chainid and a Blockscout key, and that not every action is supported, so check its per-action tables first.
  • Alchemy. Node infrastructure and JSON-RPC, with token, NFT, transfer and price APIs on top. A fit if you already run your RPC traffic through it. See GoldRush vs Alchemy.
  • Moralis. Wallet, token, NFT and price APIs plus Streams for webhook-style event delivery. See GoldRush vs Moralis.
  • QuickNode. An RPC provider that adds token, NFT and wallet data through add-ons. Worth it if you want RPC first and some data on the side. See GoldRush vs QuickNode.
  • Zerion. A wallet data API for multichain balances, positions, transactions and PnL. See GoldRush vs Zerion.
  • Your own node. JSON-RPC from a node you run, or a node provider, gives you raw chain state with no explorer in between. It doesn't give you an address's history or token list: you index that yourself.

When to stay with Etherscan

Etherscan is the better choice when you need what an explorer has and a data API doesn't:

  • Contract verification and verified source. Publishing source code from Foundry, Hardhat or Remix, and reading verified source and ABIs. These are free on every Etherscan chain, and GoldRush doesn't offer them.
  • Explorer parity. When your users check your numbers against etherscan.io, reading from the same source avoids mismatches.
  • One chain, light use. A script or research project on a free-tier chain, within 3 calls per second and 100,000 calls a day, for personal or research use.

Many teams use both: Etherscan for verification and ABIs, a data API for what their users see.

Frequently asked questions

What is the best Etherscan API alternative?

It depends on what you need. For decoded, priced wallet data across many chains in few calls, a multichain data API such as GoldRush. For a near drop-in replacement of Etherscan's module/action calls, Blockscout's API. For JSON-RPC with data add-ons, a node provider such as Alchemy or QuickNode. For contract verification, none of them: keep Etherscan.

Is the Etherscan API free?

There is a free tier: 3 calls per second and 100,000 calls a day, on selected chains only, without the PRO endpoints, for personal and research use. Paid plans ran from $49 to $899 a month when we checked on 20 November 2026, and Etherscan's terms allow commercial use from the Advanced plan ($299 a month).

Does the Etherscan API support multiple chains?

Yes. API V2 serves 57 EVM chains with one key: you pick the chain with the chainid parameter. Eleven of them, including BNB Smart Chain, Base, OP Mainnet and Avalanche C-Chain, need a paid plan. Each request covers one chain, and non-EVM chains such as Bitcoin aren't included.

How do I get every token an address holds without Etherscan PRO?

Etherscan's free tier returns one token's balance per call (tokenbalance), so you need the token contracts first. GoldRush's token balances endpoint returns the native token and every ERC-20 an address holds on a chain in one call, with fiat values and a spam flag, at 1 per call.

Can GoldRush replace Etherscan for contract verification?

No. GoldRush doesn't verify contracts or serve verified source code and ABIs. Use Etherscan (or the verification plugins for Foundry, Hardhat and Remix that publish to it) for that, and GoldRush for balances, transactions, transfers, holders and prices.

Next steps

Get new guides by email

New tutorials and best practices for building with blockchain data, sent as they're published.