How to Read Etherscan

Etherscan is the most popular blockchain explorer for Ethereum. Whether you are debugging a failed transaction, researching a smart contract, or tracking token transfers, knowing how to read Etherscan is an essential skill for anyone working in the Ethereum ecosystem. This guide walks you through every section of Etherscan, from basic transaction lookups to advanced event log analysis.

What is Etherscan?

Etherscan (etherscan.io) is a blockchain explorer — a web application that indexes and displays data from the Ethereum blockchain. Think of it as a search engine for the blockchain. Every transaction, every contract deployment, every token transfer is recorded on-chain and can be viewed through Etherscan.

Key capabilities of Etherscan:

• Look up any transaction by its hash
• View any address's balance, transactions, and token holdings
• Read and interact with verified smart contracts
• Track token transfers and approvals
• Monitor gas prices and network activity
• Verify contract source code
• Access blockchain data via API

Reading a Transaction

When you look up a transaction on Etherscan, you see a detailed page with multiple fields. Here is what each one means:

Basic Fields

Gas Information

Understanding Input Data

The Input Data field contains the raw calldata. For contract interactions, it follows this format:

0xa9059cbb  <- Function selector (first 4 bytes = keccak256("transfer(address,uint256)")[:4])
000000000000000000000000abcdef1234567890abcdef1234567890abcdef12  <- Parameter 1: address
0000000000000000000000000000000000000000000000000de0b6b3a7640000  <- Parameter 2: uint256 (1 ETH in wei)

If the contract is verified, Etherscan will decode this into human-readable form. If not, you can use our Calldata Decoder to decode it manually.

Reading a Smart Contract

When you navigate to a contract address on Etherscan, you will see several tabs that provide different views of the contract:

Contract Tab

If the contract is verified, you can view the full Solidity source code, compiler settings, and ABI. Verified contracts show a green checkmark. Key sections include:

• Code: The verified Solidity source code. Read this to understand what the contract does.
• ABI: The JSON interface that describes all functions and events. Copy this to interact with the contract programmatically.
• Creation Code: The bytecode used to deploy the contract, including constructor arguments.

Read Contract

The "Read Contract" tab lists all view/pure functions that can be called without gas. You can query values like:

• name() — Token name
• symbol() — Token symbol
• totalSupply() — Total tokens in existence
• balanceOf(address) — Token balance for an address
• owner() — Contract owner (if applicable)

Write Contract

The "Write Contract" tab lists state-changing functions. You can connect your wallet (MetaMask, etc.) and execute functions like transfer, approve, mint, and more directly from the Etherscan interface. This requires gas and signing a transaction.

Reading an Address

Looking up an address shows a wealth of information about that account:

Overview

• ETH Balance: Current balance in ETH and its USD value.
• Token Holdings: All ERC-20 tokens held by the address with USD values.
• NFTs: Any ERC-721 or ERC-1155 tokens owned.

Transaction Tabs

• Transactions: All standard external transactions (EOA to EOA or EOA to contract).
• Internal Txns: Transactions triggered by smart contract execution (contract-to-contract calls). These are not separate transactions but sub-calls within a transaction.
• Token Transfers (ERC-20): All ERC-20 token transfers involving this address. Shows incoming and outgoing token movements.
• NFT Transfers: All ERC-721 and ERC-1155 token transfers.

Understanding Event Logs

Event logs are one of the most powerful features of Etherscan for developers. When a smart contract emits an event, it creates a log entry with topics and data:

// Solidity event
event Transfer(address indexed from, address indexed to, uint256 value);

// Resulting log on Etherscan:
Topic 0: 0xddf252ad...  <- Event signature hash (keccak256 of event name + types)
Topic 1: 0x000...sender <- Indexed parameter: "from" address
Topic 2: 0x000...recipient <- Indexed parameter: "to" address
Data:    0x000...amount  <- Non-indexed parameter: "value"

Key points about event logs:

• Topic 0 is always the Keccak256 hash of the event signature (unless the event is anonymous).
• Indexed parameters appear as Topics 1, 2, and 3. You can filter logs by these values. Maximum of 3 indexed parameters.
• Non-indexed parameters appear in the Data field, ABI-encoded together.
• Events are cheaper than storage writes, making them ideal for data that only needs to be read off-chain.

Use the Event Hash Calculator to compute event signature hashes, or the Keccak256 Hash Generator to verify Topic 0 values.

Token Transfers and Approvals

Etherscan has dedicated tabs for tracking token movements, including ERC-20 token transfers. This is essential for verifying that tokens arrived, checking approval status, and auditing token flows.

Reading a Token Transfer

Each token transfer shows:

• The transaction hash that triggered the transfer
• From and To addresses
• Token name, symbol, and amount (with proper decimal formatting)
• Whether it was a direct transfer or triggered by another contract

Checking Token Approvals

To see which contracts have permission to spend your tokens, look at Approval events in the Events tab. An Approval event with a large value (like type(uint256).max) means you have granted unlimited spending permission. You can revoke approvals by calling approve(spender, 0) on the token contract.

Contract Verification

Contract verification is the process of uploading the original source code to Etherscan and proving it compiles to the exact same bytecode deployed on-chain. Verified contracts are more trustworthy because anyone can read the source code and understand what the contract does.

How to verify a contract:

1. Navigate to the contract address on Etherscan
2. Click the "Contract" tab, then "Verify and Publish"
3. Select the compiler version, optimization settings, and license
4. Paste the source code (or upload via Standard JSON Input)
5. If using constructor arguments, provide them in ABI-encoded form
6. Submit for verification

Most modern frameworks (Foundry, Hardhat) have built-in commands for Etherscan verification:

# Foundry
forge verify-contract <address> <ContractName> --etherscan-api-key <key>

# Hardhat
npx hardhat verify --network mainnet <address> <constructor-args>

Advanced Etherscan Features

Gas Tracker

Etherscan's Gas Tracker (etherscan.io/gastracker) shows real-time gas prices in three tiers (Low, Average, High) and estimated costs for common operations like ETH transfers, ERC-20 transfers, and Uniswap swaps. Use this to time your transactions for lower fees.

Etherscan API

The Etherscan API provides programmatic access to blockchain data. Common endpoints include:

// Get ETH balance
GET /api?module=account&action=balance&address=0x...&apikey=KEY

// Get transaction list
GET /api?module=account&action=txlist&address=0x...&apikey=KEY

// Get ERC-20 token transfers
GET /api?module=account&action=tokentx&address=0x...&apikey=KEY

// Get contract ABI
GET /api?module=contract&action=getabi&address=0x...&apikey=KEY

// Get gas price
GET /api?module=gastracker&action=gasoracle&apikey=KEY

ENS Lookup

Etherscan resolves ENS (Ethereum Name Service) names. You can search for vitalik.eth in the search bar and it will take you to the resolved address. Addresses with ENS names display the name for easier identification.

Token Tracker

The Token Tracker pages show rankings of ERC-20 tokens by market cap and number of holders. Each token page shows transfers, holders, and the contract information.

Alternative Block Explorers

While Etherscan is the most popular, several alternatives offer unique features:

Frequently Asked Questions