← back to blog

Reading A Transaction Page On A Block Explorer, Line By Line

Almost every piece of advice about farming safely ends with “check it on the explorer”. Check the claim contract. Check whether the transaction went through. Check what that approval actually did. Check where the funds went. It’s good advice, and it assumes you know how to read what you’ll find there.

A transaction page on a block explorer is dense. There are a dozen or more fields, several tabs, numbers in different units and addresses that sometimes have names and sometimes don’t. People learn to glance at the green “Success” badge and the value, and ignore the rest. That’s enough most of the time. It’s also how people miss that a “0 ETH” transaction moved all their stablecoins, or that a claim they thought failed actually succeeded, or that the “To” address isn’t the contract they meant to interact with.

This piece walks through a standard EVM transaction page from top to bottom, explaining what each field means and what it’s useful for. The field names used here follow the layout of the most widely used Ethereum explorer, and most EVM explorers, including those for major rollups, use the same or very similar labels. Other ecosystems, like Solana, have explorers with different structures, and those aren’t covered here.

After the fields, there are worked examples: a swap, an approval, a claim and a failed transaction. Each one shows how the same page reads differently depending on what the transaction did.

You don’t need any coding knowledge for this. You need about twenty minutes and a transaction of your own to follow along with.

Getting to the right page

Before reading a transaction, make sure you’re looking at the right one on the right explorer.

Each chain has its own explorer, or several. A transaction on one rollup won’t appear on another chain’s explorer, even though the addresses look the same. If you search a hash and get “not found”, check you’re on the explorer for the chain where the transaction happened.

Reach explorers by typing the address or using a bookmark. Fake explorers exist, usually promoted through search ads or links in scam messages, and they can show whatever the scammer wants, including a fake “Success” on a transaction that never happened.

You’ll usually arrive from your wallet. Most wallets have a “view on explorer” link in the activity list. That link contains the transaction hash, which is the unique identifier of the transaction.

You can also search an address and see its list of transactions. Clicking any row takes you to that transaction’s page. Address pages have their own layout with balances, token holdings and tabs for different transaction types, which is worth exploring separately.

Once you’re on a transaction page, the URL contains the hash. Bookmark or save the hash if it matters: it’s the reference you’ll need for support tickets, records and compensation claims.

Hash, status and the block it landed in

The top of the page identifies the transaction and tells you whether it worked.

The transaction hash is a long string starting with 0x. It’s computed from the transaction’s contents and uniquely identifies it. You can share it freely: it reveals only what’s already public on-chain.

The status is the field most people look at, and it has a few possible values. Success means the transaction was included in a block and executed without reverting. Failed, sometimes shown with an error message, means it was included in a block but the execution reverted. The chain recorded it, and you paid gas, but its effects were undone. Pending means it hasn’t been included in a block yet and is waiting in the mempool. Some explorers also show dropped or replaced for transactions that were never included or were superseded by another transaction with the same nonce.

A failed status often comes with a short error reason, such as “execution reverted” followed by a message from the contract. These messages can be informative, like an allowance or balance error, or cryptic. They’re written by the contract’s developers.

The block field shows the block number that included the transaction, often with a count of confirmations, meaning how many blocks have been added since. More confirmations means the transaction is more deeply settled. On rollups, you may also see information about whether the transaction’s batch has been posted to or finalised on the base layer.

The timestamp shows when the block was produced. It’s useful for records and for matching transactions against announcements or snapshots.

From, to and interacted with

These fields tell you who initiated the transaction and what it was sent to. They’re simple on the surface and easy to misread.

From is the address that signed and sent the transaction. For your own transactions, that’s your wallet. It paid the gas.

To is the address the transaction was sent to. For a plain transfer of the chain’s native coin, that’s the recipient. For almost anything else, it’s a contract: a token contract, a router, a claim contract, a bridge. Many explorers label this field as “Interacted With” when it’s a contract.

The difference matters. If you swap tokens on a DEX, the To address is usually the DEX’s router, not the person or pool you ended up trading with. If you claim an airdrop, the To address is the claim contract. If you transfer a token, the To address is the token contract, and the actual recipient appears elsewhere on the page, in the token transfers section.

Explorers often show a name tag next to known addresses, such as a protocol’s router or an exchange’s hot wallet. Those tags are added by the explorer and are helpful, but they aren’t guarantees. A missing tag doesn’t mean an address is malicious, and a contract can have a name of its own choosing in its code. Check contract addresses against the protocol’s official documentation, not only against the explorer’s label.

Contracts that have published their source code show a verification mark. Unverified contracts can still be legitimate, but you can’t read what they do, which is a reason for caution before interacting.

Value versus token transfers

This is the section that confuses people most.

The Value field shows how much of the chain’s native coin, such as ETH on Ethereum and many rollups, was sent with the transaction itself. For a plain ETH transfer, that’s the amount sent. For most contract interactions, it’s zero.

Zero value doesn’t mean nothing moved. Tokens like stablecoins are balances inside token contracts, separate from the native coin. When a transaction moves tokens, the Value field often stays at zero, and the movement appears in a separate section, usually titled something like “ERC-20 Tokens Transferred” or “Token Transfers”.

That section lists each token movement the transaction caused: from which address, to which address, how much and which token. A single swap might show two or more lines: your tokens going to the pool and different tokens coming back. A claim might show tokens moving from the distributor contract to your wallet. A drain would show your tokens moving to the attacker.

Read every line. Check the token’s name and contract. Spam and counterfeit tokens can appear in this section with familiar names, because the explorer is simply showing what the contracts emitted. The token’s contract address tells you whether it’s the real one.

Some transactions show NFT transfers in a similar separate section. The same logic applies: the Value field won’t tell you an NFT moved.

If you remember one thing from this section: never judge a transaction by its Value field alone. Always look at the token transfers.

The transaction action summary

Many explorers now show a decoded summary near the top, labelled something like “Transaction Action”. It might read “Swap 100 USDC for 0.03 ETH on a named DEX” or “Approved a named contract for unlimited USDC”.

This is a convenience. The explorer reads the transaction’s data and events and tries to describe them in plain words. When it works, it’s the quickest way to understand what happened.

It isn’t always complete. Complex transactions, especially those involving several contracts, may be summarised only partially. Unusual or new contracts may not be decoded at all. And the summary is only as good as the explorer’s decoding rules.

So use it as a first read, then confirm it against the token transfers section and, if needed, the logs. If the summary says “Swap” but the token transfers show your tokens leaving and nothing arriving, believe the transfers.

The summary is also a good way to spot surprises. If you thought you were claiming but the summary says you approved something, that’s worth stopping on.

What the gas fields mean

The fee section shows what the transaction cost and how that cost was calculated. It has several fields that fit together.

Gas limit is the maximum amount of computation the transaction was allowed to use, set by your wallet when it sent the transaction. Gas used is how much it actually used. Many explorers show both, with a percentage. A transaction that used nearly all its limit and failed may have run out of gas.

Gas price is the price paid per unit of gas. On chains using the fee model introduced on Ethereum in 2021, the page usually splits this into the base fee, which is set by the network and burned, and a priority fee or tip, which goes to the block producer. There’s also a max fee, which was the most you were willing to pay per unit. The details of how those interact are covered in a separate piece on gas pricing.

Transaction fee is the result: gas used multiplied by the effective gas price, shown in the native coin and often in dollars. That’s what you paid.

Some explorers show “burnt fees” and “savings”. Burnt fees are the base fee portion that was destroyed. Savings are the difference between your max fee and what you actually paid.

On rollups, the fee section often includes an additional component for posting data to the base layer, sometimes called the L1 fee or data fee. That can be a large share of the total on some chains, and it’s covered in the piece on rollup fees.

Failed transactions still show a fee. Gas pays for the attempt, whether or not it succeeded.

The smaller fields near the bottom

A few smaller fields sit in an “other attributes” area or further down the page. They’re easy to skip and occasionally important.

The nonce is a counter for transactions sent from the From address. Your first transaction has nonce 0, the next 1 and so on. Transactions from an address are processed in nonce order, so a stuck transaction with a low nonce blocks later ones. That’s a topic of its own, covered in the piece on stuck pending transactions. On the transaction page, the nonce is useful for matching a transaction to your wallet’s history and for spotting replacements.

The transaction type indicates which format was used. Most modern transactions are of the type that supports base fees and tips. Older formats still exist and occasionally show up.

Position in block shows where in the block’s ordering the transaction was placed. It rarely matters for individual users, but it’s relevant when looking at front-running or sandwich trades, where another transaction immediately before and after yours is a sign of value extraction.

Some explorers also show whether the transaction was sent through a private relay rather than the public mempool, if that can be determined.

Input data

The input data field shows the raw data sent to the contract. It’s where the transaction says which function to call and with what arguments.

In its raw form, it’s a long hex string. The first part, called the method ID or function selector, identifies which function was called. The rest encodes the arguments.

Most explorers have a decoded view for verified contracts, showing the function name and each argument with its value. For example, a token approval might decode as approve, with a spender address and an amount. A transfer might decode as transfer, with a recipient and an amount.

This is one of the most useful fields for checking what a transaction did, especially for approvals. If the decoded amount in an approval is an enormous number, it’s almost certainly the maximum possible value, meaning an unlimited approval. If the spender is an address you don’t recognise, that’s a problem.

For unverified contracts, the explorer may still guess the function from the method ID, using public databases of known function signatures. Those guesses are usually right but not guaranteed.

Plain transfers of the native coin usually have empty input data. Some people use the input data field to attach messages to transfers. Those messages can contain anything, including scams.

Logs and events

The logs tab, sometimes called events, shows the events the transaction emitted while executing.

Contracts emit events to record what happened in a way that’s easy for outside systems to read. Token transfers, approvals, swaps, deposits and claims all typically emit events. The token transfers section at the top of the page is built from these events.

Each log entry shows the contract that emitted it, an event name if decoded, and the data. For a swap, you might see transfer events for each token movement and a swap event from the pool describing the amounts in and out. For an approval, you’ll see an approval event naming the owner, the spender and the amount.

Logs are useful when the summary and the transfers section don’t tell the whole story. They show events from every contract involved, in order, which can help reconstruct complex transactions.

A caution: events are emitted by contracts, and a malicious contract can emit misleading events. This is how some address poisoning and fake token schemes make it look like transfers happened that didn’t involve real value. The token contract’s address tells you whether an event came from the real token.

Internal transactions

The internal transactions tab shows movements of the native coin that happened inside contract execution, rather than as the top-level transaction.

When a contract sends ETH to an address as part of its logic, that transfer doesn’t appear in the Value field of the main transaction, because the main transaction was sent to the contract. It appears as an internal transaction instead.

This matters in a few common cases. When you swap a token for ETH, the ETH you receive often arrives as an internal transaction from the router or a wrapping contract. When a bridge releases native coins to you, it may show up here. When a contract refunds unused ETH, that’s internal too.

If you’re looking for where ETH went, and the Value field and token transfers don’t explain it, check this tab.

Internal transactions are traces of what happened during execution, with no separate existence on the chain. Some explorers show them by default and some hide them behind a tab or an “advanced” toggle.

The state tab

Some explorers include a state tab showing how balances and storage changed as a result of the transaction. For each affected address, it shows the balance before and after.

This is a useful cross-check. If you want to know exactly how much your wallet’s native balance changed, including the fee, the state tab shows it directly.

It can also show changes to contract storage, which are harder to interpret without knowing the contract’s layout. Most users won’t need that part.

For a quick understanding, the summary, the token transfers and the fee usually suffice. The state tab is for when numbers don’t add up and you want to see the raw before and after.

Worked example: a swap

Here’s how a typical swap reads, described generically.

Status: Success. From: your wallet. To: a DEX router, with the explorer’s name tag. Value: 0 ETH, because you swapped a token, not ETH.

The transaction action summary says you swapped a certain amount of a stablecoin for a certain amount of another token.

The token transfers section shows two or more lines. Your stablecoin moving from your wallet to a pool contract, and the other token moving from the pool to your wallet. If the route went through several pools, you’ll see intermediate transfers between pools.

The fee section shows what you paid in gas.

The input data, decoded, shows a swap function with arguments including the amount in, the minimum amount out and a deadline. The minimum amount out is your slippage protection.

If the amount you received was much lower than the minimum you expected, or if there’s another transaction immediately before and after yours in the block trading the same pair, those are signs worth understanding. Sandwich attacks are covered separately.

Worked example: an approval

An approval is a transaction worth reading carefully, because it doesn’t move tokens and can still put all of them at risk.

Status: Success. From: your wallet. To: the token contract, such as a stablecoin’s contract. Value: 0.

Token transfers: none. Nothing moved, which is why approvals are easy to overlook.

The summary, if shown, says something like “Approved a named contract to spend unlimited” of the token.

The input data, decoded, shows approve with two arguments: the spender, which is the address now allowed to move your tokens, and the amount, which is often the maximum possible value.

The logs show an approval event with your address as owner, the spender and the amount.

Reading this, the key questions are: is the spender the contract you meant to approve, according to the protocol’s official documentation? And is the amount what you intended? If either is wrong, revoke the approval.

Worked example: a claim and a failure

A successful airdrop claim typically reads like this. Status: Success. From: your wallet. To: the claim or distributor contract. Value: 0. Token transfers: the airdropped token moving from the distributor to your wallet. Input data: a claim function, often with your allocation amount and a proof as arguments. The proof is a list of hashes that shows your entry is in the eligibility list.

If the token transfers show the right token contract, according to the project’s official announcement, the claim worked. If the balance doesn’t appear in your wallet, the token probably needs to be added manually.

A failed transaction reads differently. Status: Failed, with an error message such as “already claimed” or an allowance error. From and To look normal. Token transfers: none, because the execution reverted. Fee: shown, because gas was spent on the attempt.

The error message is the useful part. “Already claimed” means a previous transaction claimed successfully, which you can find in your wallet’s history. An allowance error means an approval was missing or too small. An out-of-gas failure, where gas used equals the limit, means the wallet set too low a limit.

A failed transaction doesn’t undo anything that happened in earlier transactions. It only means that one attempt had no effect beyond the fee.

Reading a transaction on a rollup

Rollup explorers look almost identical to Ethereum’s, and most fields mean the same thing. A few extra fields matter, and they’re worth recognising because farmers spend a lot of time on rollups.

The first is the data fee. A rollup transaction pays for its own execution on the rollup, and also for its share of the cost of posting data to the base layer. Explorers often show this as a separate line, sometimes called the L1 fee, or combine it into the total with a breakdown available. When a rollup transaction costs more than you expected, this line is usually why.

The second is batch or settlement status. Rollups bundle many transactions into batches and post them to the base layer. Some explorers show whether a transaction’s batch has been posted, and whether it’s considered final on the base layer. For everyday use, the rollup’s own confirmation is usually enough. For large withdrawals or bridge transfers, the base-layer status tells you how settled the transaction really is.

The third is cross-layer messages. Deposits from the base layer to a rollup, and withdrawals back, often involve two transactions: one on each layer. The rollup explorer may link to the corresponding base-layer transaction, or show the message status. Withdrawals from some rollups have a waiting period before they can be finalised on the base layer, and the explorer may show where in that process a withdrawal is.

Everything else reads the same way. Status, From, To, token transfers, input data and logs work as described above. The main habit to add on a rollup is checking the fee breakdown when costs look strange, and checking settlement status when the amount matters.

A bridge transfer is two pages

Bridging is one of the most common farming actions, and one of the most confusing to read, because a single transfer involves at least two transactions on two different chains.

On the source chain, you send a transaction to the bridge’s contract. Its page shows your tokens leaving your wallet, going to the bridge contract or being burned, depending on the bridge’s design. Status Success on this page means the bridge received your funds. It doesn’t mean they’ve arrived on the other side.

On the destination chain, a separate transaction releases or mints the tokens to your address. That transaction might be sent by a relayer, the bridge’s own infrastructure or, for some bridges, by you. Its From address is often not yours. Its token transfers show the tokens arriving in your wallet.

Matching the two can take a little work. Many bridges have their own explorer or status page where you paste the source transaction hash and see the destination transaction. Some block explorers show a link between them. Otherwise, you can look at your wallet’s address on the destination chain’s explorer for an incoming transfer of the right token around the right time.

When a bridge transfer seems stuck, the source chain page tells you the first leg completed. The bridge’s status page tells you where the second leg is. Check both before assuming anything is lost, and use the bridge’s official status page rather than links from chats, since bridge delays are a favourite moment for fake support.

Using the address page alongside

Transaction pages answer “what did this transaction do?”. Address pages answer “what has this wallet done?”. Reading them together is often the fastest way to understand a situation.

An address page lists transactions sent from and to the address, usually with separate tabs for native transfers, token transfers, NFT transfers and internal transactions. Many explorers let you filter by direction, by token or by status, including showing only failed transactions.

It also shows token holdings, often with a spam filter, and sometimes an approvals checker, which lists every contract the address has approved to spend its tokens, with the option to revoke. That tool is worth knowing well, because it’s the quickest way to check what your wallets have granted.

For farmers, address pages are useful for spotting patterns across a wallet’s history: when it was funded, which protocols it’s used and whether any unexpected transactions appear. They’re also where address poisoning attempts show up, as zero-value or dust transfers from lookalike addresses.

If you use private labels on your explorer, apply them to your own wallets and to the contracts you use regularly. Transaction pages then show your labels in the From and To fields, which makes reading them much faster.

Habits that make the explorer useful

A few habits turn the explorer from a place you visit in a panic into a routine check.

Look at your important transactions after they confirm, not only when something goes wrong. A quick look at the token transfers and the To address catches surprises early.

Check approvals specifically. After approving anything, open the transaction and confirm the spender and amount.

Save hashes for anything significant: claims, large transfers, deposits to exchanges. They’re what support teams and compliance reviews ask for.

Use private labels if your explorer offers them. Tagging your own wallets and the protocols you use makes transaction pages far easier to read at a glance.

Compare contract addresses against official sources, not explorer tags alone.

And when a page doesn’t make sense, go slowly: status, from, to, token transfers, fee. Those five fields answer most questions.

Where the explorer can mislead

The explorer shows what’s on-chain, faithfully. But how it presents that can mislead if you aren’t careful.

Token names and symbols are chosen by whoever deployed the contract. The explorer displays them as given. Always check the contract address.

Events can be emitted by malicious contracts to look like real transfers. That’s how some fake transfers appear in your history.

Name tags are helpful but maintained by the explorer, and not every legitimate contract has one.

Dollar values are estimates based on the explorer’s price sources, and can be wrong for thinly traded tokens.

Pending and dropped statuses depend on what the explorer’s nodes have seen, and different explorers can briefly disagree.

None of this makes the explorer unreliable. It’s the most direct view of the chain most people have. It just means reading it with the same care you’d give anything else that affects your funds.

For more on reading the chain, checking what you signed and the habits that keep a farm’s activity legible, head back to the Airdrop Farming homepage.

Get new guides and videos first — join the Telegram channel.

need infra for this today?