Etherscan and its cousins are the most powerful tools in Web3. Most people use 5% of what they offer. Here’s how to use the other 95%.
If you’ve ever clicked “View on Etherscan” from a wallet, you’ve used a block explorer. You probably stared at a page of hex strings, numbers, and unfamiliar tabs, found the one thing you were looking for, and closed the tab.
Block explorers are dense for a reason: they expose everything a blockchain knows. Once you learn to read them, you can verify any transaction in the world, decode any smart contract interaction, debug any failed action — and avoid an enormous category of scams.
Here’s the guided tour.
What a block explorer actually is
A block explorer is a website that indexes a blockchain and lets you search it. Behind the scenes, it runs a full archive node and serves a friendly interface on top of the raw blockchain data.
Major explorers by network:
- Ethereum: etherscan.io
- Polygon: polygonscan.com
- Base: basescan.org
- Arbitrum: arbiscan.io
- Optimism: optimistic.etherscan.io
- BNB Chain: bscscan.com
They share the same UI patterns and data structure (most are operated by Etherscan or use Etherscan’s open codebase), so learning one teaches you all of them.
Everything on a block explorer comes directly from the blockchain. None of it is editorial. If Etherscan shows you a transaction, that transaction happened. If it shows zero balance for an address, that address has zero balance — there’s no curated layer in between.
The four things you can search
The search bar at the top accepts:
- Transaction hash (a 64-character hex string starting with
0x) — looks up a specific transaction - Block number (or block hash) — looks up a specific block
- Address (a 40-character hex string starting with
0x) — looks up a wallet or contract - ENS name (e.g.,
vitalik.eth) — resolves to the underlying address
Most of the time, you’re either pasting in a transaction hash from your wallet, or pasting in an address you want to inspect.
Reading a transaction page
This is the page you’ll see most often. Click any transaction hash and you get a detail view with about 15 fields. Here’s what each one means and which ones matter.
The status bar at the top
- Status: Success — the transaction was included in a block and didn’t revert
- Status: Fail — the transaction was included but reverted (you still paid gas)
- Status: Pending — the transaction is in the mempool, not yet included
A failed transaction is real. It costs gas. The “Fail” status just means the smart contract being called rejected the call.
Transaction details
Transaction Hash — the unique ID. Copy this if you want to share or look it up later.
Block — which block the transaction was included in. The “(X Block Confirmations)” tells you how many blocks have been added since, which is a rough measure of finality.
Timestamp — when the block was mined/proposed. Hover for exact time.
From — the address that signed and sent the transaction. This is the wallet that paid the gas.
To — the recipient. For a simple transfer, this is the destination wallet. For a contract interaction, this is the smart contract being called (often a router, DEX, or token contract).
Value — the amount of native currency (ETH, MATIC, etc.) sent with the transaction. This is not the value of any ERC-20 tokens transferred. A USDC transfer might show “0 ETH” value because no ETH was sent — only USDC.
Fees
Transaction Fee — total paid by the sender (gas used × effective gas price)
Gas Price — the per-unit cost paid
Gas Limit & Usage by Txn — how much gas was reserved vs how much was actually used. Anything below the limit gets refunded automatically.
Gas Fees / Burnt & Txn Savings — under EIP-1559, the base fee is burned and any saved priority fee is refunded.
The hidden important parts
This is where most people stop. The good stuff is below.
Click “Click to see More” to expand additional fields. Then look at:
Input Data — the raw call data sent to the contract. For complex transactions, this includes everything the contract was asked to do. Etherscan can usually decode it if the contract is verified.
The decoded view shows:
Function: transfer(address _to, uint256 _value)
MethodID: 0xa9059cbb
[0]: 000000000000000000000000abc... (recipient address)
[1]: 00000000000000000000000000000000000000000000000005f5e100 (amount: 100,000,000)
For a USDC transfer, that “100,000,000” is 100 USDC (USDC has 6 decimals). This is how you verify that a transaction is actually doing what someone told you it does.
ERC-20 / NFT transfers
On a transaction page, scroll down to find:
ERC-20 Tokens Transferred — lists every ERC-20 token movement triggered by this transaction. A Uniswap swap shows tokens going in and tokens coming out. A flash loan shows borrow + repay in the same transaction.
ERC-721 Tokens Transferred — same for NFTs.
This is the human-readable summary of what actually happened economically. If someone says “this transaction sent me 5 ETH” and the ERC-20 transfers section shows different tokens, they’re either confused or lying.
Reading an address page
Click any address (yours, a friend’s, a contract, anything) and you get a profile page.
Account summary
- Balance — current native token balance
- Tokens — dropdown of every ERC-20 the address holds
- Multichain Portfolio — if available, shows balances on other chains too
- Transactions count — how many transactions this address has sent
For most wallets, the balance shown is current and accurate. For NFTs, scroll to the “NFTs” tab.
Tabs you’ll use
- Transactions — every transaction sent or received by this address
- Internal Txns — transactions triggered by smart contracts on behalf of this address (often invisible to the user but real)
- Token Transfers — every ERC-20 in or out
- NFT Transfers — every NFT in or out
- Contract — only appears if the address is a smart contract. Shows the code.
The “Contract” tab — the most powerful section
If the address you’re looking at is a contract (not a regular wallet), there’s a Contract tab. Click it.
Three sub-tabs matter:
Code — the verified source code of the contract. If the contract is verified, you can read the actual Solidity (or Vyper) code that runs every time someone interacts with it. If a contract is not verified, treat it with serious suspicion — the developer is asking you to trust code you can’t read.
Read Contract — every read-only function on the contract, exposed as a form. You can call any of them directly from the browser without paying gas. Want to know the total supply of a token? Click totalSupply(). Want to check the owner? Click owner(). This is incredibly useful for verifying that contracts work the way someone claims.
Write Contract — every write function. You can call them by connecting your wallet through the browser. Useful for emergency interactions when the dApp’s UI is broken or sketchy.
Tags and labels
Etherscan adds labels to known addresses:
- “Binance Hot Wallet 1”
- “Uniswap V3: Router”
- “Tornado Cash: 0.1 ETH”
- “Vitalik.eth”
These are crowd-sourced and curated. They’re useful context but not authoritative — anyone can mimic a label, and Etherscan only labels addresses they’ve verified.
The “Comments” section
Some explorers let users leave comments on addresses. These are not authoritative, often spammy, and occasionally include legitimate warnings about scam contracts or hacked addresses. Read with skepticism.
Reading a block page
Less commonly needed, but useful for context. A block page shows:
- Block height — the block’s position in the chain
- Timestamp — when it was produced
- Transactions — every transaction included
- Validator / Miner — who produced the block
- Gas Used / Limit — how full the block was (>50% means base fee will rise)
- Block Reward — total fees collected by the validator
Useful for understanding network congestion: a string of blocks at 99% capacity means fees are about to climb.
Things you can do that most people don’t
A few practical skills that block explorers unlock:
Verify a token contract before buying
Before buying any token, paste its contract address into the explorer:
- Is the contract verified? If not, walk away.
- Read the source code for anything suspicious — taxes, blacklists, mint functions that the owner can call.
- Check token holders. A token where 90% is held by one wallet is a rug-pull risk.
- Check the contract creation transaction. A token deployed minutes ago by an anonymous wallet is much riskier than one deployed years ago by a known team.
Trace a complex transaction
For DeFi transactions that touch multiple contracts:
- Open the transaction
- Scroll to Internal Txns — see every call the original transaction triggered
- Scroll to State Diff (if available) — see every storage change the transaction made
This lets you reconstruct exactly what happened, especially useful when something didn’t go as expected.
Find related transactions
On an address page:
- Click Transactions
- Use filters at the top: From, To, date range
- Search the full history of every interaction this address has ever had
Useful for tracing fund flows, auditing protocols, or just satisfying curiosity about what a famous wallet has been doing.
Watch live mempool activity
Some explorers (Etherscan has this for Ethereum) include a Pending Transactions view. You can see transactions that have been broadcast but not yet included in a block. Useful for understanding network congestion in real time.
Subscribe to address activity
Most explorers let you create a free account and set up alerts:
- Email when a specific address sends or receives
- Email when a specific contract is called
- Watchlists for tracking multiple addresses
Useful for monitoring your own wallets, watching whale activity, or tracking projects you care about.
How to spot scams using a block explorer
A few patterns that immediately tell you something is wrong:
Unverified contracts. If a project tells you to interact with a contract and the contract isn’t verified, you’re being asked to trust a black box. Real projects verify.
New contracts pretending to be old. A “USDC” token created yesterday by a random wallet isn’t real USDC. Check the contract address against the official one (usually listed on the project’s website).
Honeypot tokens. Look at the holder list. If only the creator has ever sold this token successfully, you’re looking at a honeypot — you can buy but can’t sell.
Approval scams. Check if the contract you’re about to approve actually does what it claims. The “Read Contract” tab will tell you.
Phishing addresses. A real address from a project will match across all their official channels. Scammers often use addresses that look similar (same prefix, similar middle) but differ by a few characters. Always copy-paste from official sources, never type by hand.
A practical exercise
To make this concrete, try this with any wallet you own:
- Open the explorer for the chain (e.g., etherscan.io for Ethereum)
- Paste your address
- Look at your full transaction history
- Click into one transaction from a few months ago
- Read every field on the page
- Try to reconstruct exactly what you were doing that day
It’s surprisingly useful. Most people don’t realize how much they’ve forgotten about their own wallet activity until they look at it laid out chronologically.
The bottom line
Block explorers are the closest thing crypto has to public records. Everything that happens on a blockchain is on them — every transfer, every contract interaction, every block. The data is permanent, free to access, and impossible to forge.
Learning to read them well is a small investment that pays back constantly:
- Verify what dApps tell you they did
- Confirm transactions before getting nervous
- Audit contracts before interacting
- Track funds, your own and others’
- Spot scams that depend on you not looking
The full power of a public blockchain is in the public part. Block explorers are how you actually use it.
Block explorers and RPC endpoints work together — explorers index the same data that RPCs serve directly. If you’re building tools that query blockchains programmatically, free public RPCs at rpcfree.com cover the same four major networks.