Skip to content

ERC-20 Token Inspector

Paste an ERC-20 contract address. Get the token name, symbol, decimals, and total supply formatted with the right precision in one read.

Ethereum Base BNB Smart Chain no signup · no wallet connect · free

The one query that powered this

cel.bind(d, token.decimals(), {
  "name":        token.name(),
  "symbol":      token.symbol(),
  "decimals":    string(formatUnits(d, 0)),
  "totalSupply": string(formatUnits(token.totalSupply(), d))
})

One expression. Auto-resolved ABI, EIP-1967 unwound, Multicall3 batched. Run this in your own code →

What this tool does

The ERC-20 Token Inspector reads any ERC-20 token contract and returns the token name, symbol, decimals, and total supply from one expression. It is built for developers, integrators, and analysts who need to confirm what a token is and how much of it exists without writing ABI files or remembering the right formatUnits math.

How to use it

  1. Paste the ERC-20 contract address into the form above.
  2. Pick the chain the contract is deployed to.
  3. Run the query and read the token name, symbol, decimals, and total supply in the result panel.

The result panel shows the human-readable name and symbol, the on-chain decimals value, and the total supply formatted with the contract’s own decimals so you don’t have to do the division yourself. The raw integer total supply is shown alongside for reference.

What is happening under the hood

Every ERC-20 token contract exposes the same four read functions: name(), symbol(), decimals(), and totalSupply(). They are independent reads, so a naive client makes four sequential eth_call round trips. evmquery batches them into one Multicall3 call and decodes the typed results in a single response.

cel.bind(d, token.decimals(), {
  "name":        token.name(),
  "symbol":      token.symbol(),
  "decimals":    string(formatUnits(d, 0)),
  "totalSupply": string(formatUnits(token.totalSupply(), d))
})
  • cel.bind(d, token.decimals(), …) reads decimals() once and reuses it. We need it twice: once to display, once to scale totalSupply into a human-readable number.
  • name() and symbol() return strings directly. evmquery resolves the contract ABI from verified source so you don’t need to ship one.
  • formatUnits(token.totalSupply(), d) divides the raw integer supply by 10 ** decimals server-side, so a USDC supply of 54785398641598465 returns as "54785398641.598465" ready for display.
  • All four results are returned as strings so they fit in the same map. CEL maps require their values to share a type, and string(formatUnits(…)) is the conversion path that works for both small ints (decimals) and large supplies.
  • Multiple reads are auto-batched by Multicall3, so the cost is one round trip regardless of how many fields you ask for.

Build this yourself

Each of the snippets below makes the same POST call to the evmquery REST API. The expression is the one shown above with your contract address filled in. The example targets USDC on Ethereum.

REST (curl)

curl -X POST https://api.evmquery.com/api/v1/query \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "evm_ethereum",
    "schema": {
      "contracts": { "token": { "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } }
    },
    "expression": "cel.bind(d, token.decimals(), { \"name\": token.name(), \"symbol\": token.symbol(), \"decimals\": string(formatUnits(d, 0)), \"totalSupply\": string(formatUnits(token.totalSupply(), d)) })"
  }'

Python

import requests

resp = requests.post(
    "https://api.evmquery.com/api/v1/query",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "chain": "evm_ethereum",
        "schema": {
            "contracts": {"token": {"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"}},
        },
        "expression": (
            "cel.bind(d, token.decimals(), {"
            ' "name": token.name(),'
            ' "symbol": token.symbol(),'
            ' "decimals": string(formatUnits(d, 0)),'
            ' "totalSupply": string(formatUnits(token.totalSupply(), d))'
            " })"
        ),
    },
    timeout=10,
)
print(resp.json()["result"])

TypeScript

const resp = await fetch("https://api.evmquery.com/api/v1/query", {
	method: "POST",
	headers: {
		Authorization: `Bearer ${process.env.EVMQUERY_API_KEY}`,
		"Content-Type": "application/json",
	},
	body: JSON.stringify({
		chain: "evm_ethereum",
		schema: {
			contracts: { token: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } },
		},
		expression:
			'cel.bind(d, token.decimals(), { "name": token.name(), "symbol": token.symbol(), "decimals": string(formatUnits(d, 0)), "totalSupply": string(formatUnits(token.totalSupply(), d)) })',
	}),
});
const { result } = await resp.json();

The free tier covers 2,000 reads per month. Get a free API key to drop these snippets into your project.

When you would use this

  • Listing or integrating a new token. Confirm the token name, symbol, and supply on-chain before you wire it into a UI, an indexer, or a treasury report.
  • Sanity-checking an address. Quickly verify that an address is actually an ERC-20 contract and not an EOA, an NFT, or a different standard.
  • Treasury and analytics dashboards. Read the canonical decimals so your aggregated balances render with the right precision instead of off by 10 ** 12.
  • Writing developer docs. Show readers a working ERC-20 read example without making them set up a node, an ABI file, or a wallet connection.

FAQ

What is ERC-20?

ERC-20 is the fungible token standard on Ethereum and EVM-compatible chains. The standard defines a small set of read and transfer functions every compliant contract must expose, which is why one inspector works for every ERC-20.

Why does decimals matter for total supply?

ERC-20 contracts store balances as integers. The decimals value tells you how to interpret those integers as a human number. USDC stores supply with 6 decimals, DAI with 18. The Inspector reads decimals first and formats the total supply for you so you don’t have to divide by hand.

Which chains are supported?

The Inspector currently runs against Ethereum, Base, and BNB Smart Chain. Additional EVM chains are being added on the evmquery backend. If you need a specific chain prioritized, contact support.

Does evmquery work with proxy contracts?

Yes. evmquery automatically resolves EIP-1967 transparent and beacon proxies to their implementation, so you paste the proxy address and the reads land on the right ABI. Most upgradeable stablecoins (USDC, USDT) are proxies.

Why does the read fail for some addresses?

The expression assumes the contract implements ERC-20. If the address is an externally owned account, an unrelated contract, or only partially implements ERC-20, the read can fail. Double-check the address on a block explorer if you see a validation error.

Can I use this tool from my own application?

Yes. The same expression and contract address work against the public REST API. The free tier includes 2,000 reads per month, and a single inspection counts as one read because Multicall3 batches all the underlying calls into one round trip. Bring your own API key and the rate limit applied to this page no longer applies.

Limits and accuracy

  • The result reflects the latest block at the time of the read. There is no historical replay.
  • The total supply is the on-chain totalSupply() value. For tokens with mint and burn events that affect circulating supply, you may want to subtract known treasury or burn-address balances to get the circulating number.
  • The demo is rate limited per browser. If you hit the limit, grab a free API key and the limit goes away.
  • USD pricing, market cap, and liquidity are out of scope. evmquery returns raw on-chain values, not aggregated market data.

Run this query in your own code

Free tier covers 2,000 reads per month. No credit card needed.

Get a free API key Read docs