Skip to content
Crypto.world

Practical Guides

How to Read an Ethereum Transaction on a Block Explorer

A step-by-step reading of one real mainnet USDC transfer on a block explorer: status, from and to, gas limit and gas used, base and priority fee, burnt fee, nonce, input data, the Transfer event, and…

How to Read an Ethereum Transaction on a Block Explorer

Start From the Hash, on an Explorer You Reached Yourself

Etherscan's Information Center calls a block explorer "a search engine for a blockchain": give it a transaction hash, an address or a block, and it shows what the chain recorded. Etherscan is the example here because its help pages describe its fields. ethereum.org's page on block explorers splits its list into open-source tools (Blockscout and Otterscan among them) and services (Etherscan and Blockchair among them), all reading the same chain.

A fake page can imitate any of them. ethereum.org's guide to scam tokens warns of "very convincing websites, sometimes even precise clones of authentic sites", and advises you to "carefully check the URL" and keep authentic sites in your bookmarks. So the first steps come before the hash:

  1. Open the explorer from a bookmark or by typing its address, such as etherscan.io or eth.blockscout.com, both linked from ethereum.org's explorer list. Do not arrive through a link someone sent you.
  2. Paste the transaction hash into the search bar. A hash is 66 characters: 0x followed by 64 hexadecimal digits.
  3. If nothing comes up, suspect the hash, the network or the timing first. Blockscout's field reference lists "Wrong hash, wrong network, too recent" as the possible causes of a transaction not found.

The Specimen: A USDC Transfer That ethereum.org Already Dissects

The walkthrough follows one mainnet transaction, hash 0xd0dcbe007569fcfa1902dae0ab8b4e078efe42e231786312289b1eee5590f6a1, in block 14,330,693 at 02:41:09 UTC on 6 March 2022. ethereum.org's Transactions page dissects the same hash, so you can read a second explanation of this very transaction there. USDC appears only because the specimen is a transfer of it; nothing here is a view on any token.

Every figure below is on the Etherscan page for the hash or can be re-derived from the transaction, receipt and block objects that any Ethereum node returns through JSON-RPC (eth_getTransactionByHash, eth_getTransactionReceipt, eth_getBlockByNumber), which ethereum.org's JSON-RPC documentation describes. The table uses Etherscan's row labels; other explorers word theirs differently.

Etherscan label Value in the specimen
Status Success
Block 14330693
From 0xbAE7EBe87fc708426A193f49c4829CdC6221AC84
Interacted With (To) 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
Value 0 ETH
Transaction Fee 0.001332533053797825 ETH
Gas Price 30.475312837 Gwei
Gas Limit & Usage by Txn 84,000, then 43,725 (52.05%)
Gas Fees Base 30.375312837 Gwei; Max 39.39 Gwei; Max Priority 0.1 Gwei
Burnt & Txn Savings Fees Burnt 0.001328160553797825 ETH; Txn Savings 0.000389794696202175 ETH
Txn Type 2 (EIP-1559)
Nonce 0

From, To, Value: Why a Token Transfer Is Sent to the Token, Not the Recipient

Start with Status. Etherscan's help page names the statuses Successful, Pending, Failed and Dropped; on the page itself the specimen reads Success, and a failed transaction reads Fail. From is the account that signed and paid; ethereum.org notes that contract accounts cannot send transactions, so it is an externally-owned account.

To is the row that gets misread. ethereum.org defines to as the receiving address and adds that if it is a contract account, "the transaction will execute the contract code". In the specimen, the row labelled "Interacted With (To)" holds the USDC token contract, not the person who received tokens. The recipient is data: an argument in the input and an indexed field of the Transfer event, both decoded below.

Blockscout's field reference lists one token-transfer pattern: from a user wallet, to the token contract, 0 ETH, a function call as input. Value counts native ETH only, and here it is 0. The tokens changed hands by editing a ledger inside the token contract; as ethereum.org puts it, an ERC-20 balance is "part of the ERC-20 contract's storage". Etherscan adds an "ERC-20 Tokens Transferred" row and Blockscout a "Token transfers" tab as shortcuts. The raw record is the Transfer event in the logs, covered below.

Gas, Line by Line: Limit, Used, Base Fee, Priority Fee, Burnt Fee

EIP-1559, now marked Final, defines who pays what:

Senders will always pay the base fee per gas of the block their transaction was included in, and they will pay the priority fee per gas set in the transaction, as long as the combined amount of the two fees doesn’t exceed the transaction’s maximum fee per gas. — Vitalik Buterin, Eric Conner, Rick Dudley, Matthew Slipper, Ian Norden and Abdelhamid Bakhta, authors of EIP-1559 "Fee market change for ETH 1.0 chain", Ethereum Improvement Proposals

The sender chooses three numbers: a gas limit (84,000 here), a max priority fee (0.1 gwei) and a max fee (39.39 gwei). The protocol supplies the fourth, the block's base fee (30.375312837 gwei). Every fee is per unit of gas, and a gwei is one billionth of an ETH. The EIP's reference code turns these into the price actually charged (object prefixes dropped here):

priority_fee_per_gas = min(max_priority_fee_per_gas, max_fee_per_gas - base_fee_per_gas)
effective_gas_price = priority_fee_per_gas + base_fee_per_gas

The room under the cap is 39.39 − 30.375312837 = 9.014687163 gwei, more than the 0.1 gwei tip offered, so the priority fee is 0.1 gwei and the effective price is 30.475312837 gwei: the Gas Price row. In a receipt, ethereum.org's JSON-RPC documentation defines effectiveGasPrice as the base fee plus the tip paid per unit of gas. Now check the money:

  1. Transaction Fee: 43,725 gas used × 30.475312837 gwei = 0.001332533053797825 ETH.
  2. Burnt: 43,725 × the 30.375312837 gwei base fee = 0.001328160553797825 ETH. The EIP says the base fee is burned and that miners "only get to keep the priority fee".
  3. Tip: 43,725 × 0.1 gwei = 0.0000043725 ETH, about 0.33% of the fee, paid to the block producer (the EIP says miners, ethereum.org says validators). Steps 2 and 3 add up to step 1.
  4. Txn Savings: (39.39 − 30.475312837) gwei × 43,725 = 0.000389794696202175 ETH, the gap between the cap and the price paid.

The Gas Limit & Usage by Txn row shows that only gas used is billed: the 40,275 units of the limit that went unused cost nothing, because ethereum.org states that unused gas is refunded. The balance still had to cover the cap. In the EIP's reference code a transaction is invalid unless the signer can afford the gas limit times the max fee, here 84,000 × 39.39 gwei = 0.00330876 ETH.

Explorers compute derived fields such as the gas price and the fee themselves, so two of them can show different figures for one transaction. When a figure matters, compare two explorers or the node's receipt, and recompute the fee from Base, Max, Max Priority and gas used.

Nonce and Txn Type: Transaction Order and Format

Etherscan's help page defines the nonce as the "Number of the transaction sent from the sender’s address", numbered sequentially from 0, so a nonce of 10 is the 11th transaction from that address. The specimen's nonce is 0: its sender's first transaction. Asking a node for the sender's transaction count (eth_getTransactionCount) returns 0 at block 14,330,692 and 1 at block 14,330,693. Blockscout's reference adds the purpose: the nonce prevents replay attacks and ensures ordering.

Txn Type tells you which fee fields to expect. ethereum.org describes Type 0 as the original legacy format, Type 1 as the access-list format from EIP-2930 and Type 2 as the EIP-1559 format, introduced in the London upgrade (5 August 2021 by Etherscan's account; block 12,965,000 in the Ethereum Foundation's announcement).

On Etherscan a Type 2 page's Gas Fees row shows Base, Max and Max Priority; a Type 0 page shows Base only, beside a single Gas Price. EIP-1559 says legacy transactions "will still work and be included in blocks, but they will not benefit directly from the new pricing system". Newer types exist, so an unfamiliar number is not an error.

Input Data and Logs: How the Page Knows This Was a Transfer

The Input Data row holds the call. ethereum.org explains that the first four bytes name the function, "using the hash of the function's name and arguments", and the rest is the arguments, encoded as the ABI specification describes. The specimen's input splits into a selector and two 32-byte words:

0xa9059cbb
0000000000000000000000004f6742badb049791cd9a37ea913f2bac38d01279
000000000000000000000000000000000000000000000000000000003b0559f4

The selector 0xa9059cbb is the first four bytes of the Keccak-256 hash of transfer(address,uint256), which can be recomputed. Etherscan prints the function name because the token's source code is verified there; without verified source an explorer may show only the selector, which signature databases such as 4byte.directory can match, sometimes to several functions (ethereum.org).

The first word is the recipient's address padded to 32 bytes, 0x4f67…1279. The second, 0x3b0559f4, is 990,206,452 in raw units. EIP-20 makes decimals optional, so ask the contract: USDC's decimals() returns 6, and Blockscout lists 6, making the amount 990.206452 USDC.

Now open the Logs tab, labelled "Logs (1)" on Etherscan. It holds one entry, emitted by the token contract's own address, with three topics. The first, 0xddf252ad…523b3ef, is the Keccak-256 hash of Transfer(address,address,uint256); the second is the sender and the third the recipient, each padded to 32 bytes. The data field carries the amount, 0x3b0559f4.

That is the layout Etherscan describes: topic0 is "essentially a Keccak256 hash of the event signature", parameters declared indexed become topics, and the rest go in data. EIP-20 declares Transfer(address indexed _from, address indexed _to, uint256 _value) and says it "MUST trigger when tokens are transferred, including zero value transfers."

Even so, a Transfer entry is only the contract's own statement. As ethereum.org puts it: "Transfer events are produced by the ERC-20 contract. A scammer can easily write the contract in such a way it will produce those actions." The next question is which contract this is.

Checking the Token Contract: The Address First, Verified Code Second

  1. Compare the whole address with the issuer's own publication. Circle's developer documentation lists USDC on Ethereum Mainnet as 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, matching the To row. ethereum.org's rule: "Scam tokens cannot use the same contract address", and the best source for the genuine address "is the organization whose token it is".
  2. Ignore name and symbol as proof. ethereum.org: "ERC-20 contracts can have the same symbol and name as other ERC-20 contracts. You cannot count on those fields for security."
  3. Open the address page and its Contract tab. Etherscan's help page defines "Exact Match" as "The published source code fully matches the deployed bytecode"; a "Similar Match" only means the bytecode matches a previously verified contract and may differ in constructor arguments or initialization. The specimen's address showed Source Code Verified and Exact Match in October 2026.
  4. Read the limits of that badge. Etherscan's safety guide says verification "only confirms that the published source code corresponds to what is running on the blockchain"; it does not mean the contract is safe or audited. ethereum.org adds that scam tokens sometimes publish their source to look legitimate.
  5. Look for a name tag, and treat it as a signal. Etherscan's guide: "If no name tag is present, verify the contract address using official project sources before interacting with it." The specimen address carried the public tag "Circle: USDC Token". ethereum.org cautions that Etherscan "is not an authoritative source of truth", which is why step 1 comes first.
  6. Notice proxies. The page showed a Proxy badge with an implementation address, and Blockscout reports one too. Etherscan explains that proxies forward calls to another contract so logic can be upgraded, and that under the EIP-1967 standard an upgrade changes the stored implementation address. Its proxy-related tabs lead to the implementation's code.

What a Failed Transaction Still Costs

ethereum.org's gas page says: "The fee is paid regardless of whether a transaction succeeds or fails." Etherscan agrees for failed transactions: the funds the sender meant to send stay in the wallet, but the gas fee is still deducted. The computation was performed either way. If a transaction runs out of gas mid-execution, ethereum.org says "the EVM will revert any changes, but all the gas provided will still be consumed for the work performed".

One case costs nothing: ethereum.org says a gas limit too low to pass validation, such as 20,000 for a simple ETH transfer, is "rejected before being included in a block, and no gas will be consumed", so there is no on-chain record to read.

On Etherscan a failed transaction reads Fail. One from the specimen's block, 0x623853dbbe7c283ce916fd865607bc961cfd6f0bfe8aaf44b45bb87c60d87753, shows the warning "Error encountered during contract execution [Out of gas]", used 77,827 of its 77,827 gas units and still lists a Transaction Fee of 0.002568291 ETH. It is a Type 0 transaction, so check 1 does not apply; checks 2 and 3 do, taking the Gas Price row as the price: 77,827 × 33 gwei = 0.002568291 ETH, and 77,827 × 30.375312837 gwei = 0.002364019472165199 ETH burnt.

Etherscan's help page lists failure reasons such as Out of Gas, Reverted, Bad Jump Destination and Bad Instruction, and Blockscout shows a Revert Reason field. For tokens, Etherscan names three common causes: a locked token contract, an insufficient token balance, and a contract that deducts a balance without emitting a Transfer event, which it calls not fully ERC-20 compliant. A Success status with no Transfer entry in the logs therefore deserves a second look.

To test yourself on any Type 2 transaction, success or failure, copy Base, Max, Max Priority and gas used from the page, then work through three checks:

  1. Take the smaller of Max Priority and Max minus Base, and add Base. The result must equal the Gas Price row.
  2. Multiply that price by gas used. The result must equal the Transaction Fee.
  3. Multiply Base by gas used. The result must equal the burnt amount.

If a row disagrees, query the receipt from a node and compare effectiveGasPrice.

Sources

  1. EIP-1559: Fee market change for ETH 1.0 chain (Ethereum Improvement Proposals) eips.ethereum.org
  2. EIP-20: Token Standard (Ethereum Improvement Proposals) eips.ethereum.org
  3. ethereum.org: Transactions ethereum.org
  4. ethereum.org: Gas and fees ethereum.org
  5. ethereum.org: JSON-RPC API ethereum.org
  6. ethereum.org: Block explorers ethereum.org
  7. ethereum.org: How to identify scam tokens ethereum.org
  8. ethereum.org: Some tricks used by scam tokens and how to detect them ethereum.org
  9. Etherscan Information Center: What is a Block Explorer? info.etherscan.com
  10. Etherscan Information Center: What is a Transaction Hash (Txn hash)? info.etherscan.com
  11. Etherscan Information Center: Viewing Transactions on Etherscan info.etherscan.com
  12. Etherscan Information Center: What is Gas Fee? info.etherscan.com
  13. Etherscan Information Center: Event Logs info.etherscan.com
  14. Etherscan Information Center: Navigating the Contract Code tab info.etherscan.com
  15. Etherscan Information Center: How to Safely Interact with Smart Contracts on the Explorer info.etherscan.com
  16. Etherscan Information Center: Types of Proxy Contracts Detected by Etherscan info.etherscan.com
  17. Etherscan Information Center: What are the Reasons for Failed Transactions? info.etherscan.com
  18. Blockscout Docs: Transaction Fields Reference docs.blockscout.com
  19. Circle Developer Docs: USDC contract addresses developers.circle.com
  20. Ethereum Foundation Blog: London Mainnet Announcement blog.ethereum.org
  21. Etherscan: the specimen transaction page etherscan.io
  22. Etherscan: a Type 0 (legacy) transaction page, same block as the specimen etherscan.io
  23. Etherscan: a failed transaction page, same block as the specimen etherscan.io
  24. Etherscan: USDC token contract address page etherscan.io
  25. Blockscout API: the specimen transaction and its logs eth.blockscout.com

Related stories

Explore

More articles