Ethereum Transaction Decoder

Paste a raw signed Ethereum transaction to see nonce, fees, recipient, value, chain ID, access list and ERC-20 calldata, decoded offline from RLP.

The interactive tool loads here when JavaScript runs.

About this tool

What is the Ethereum Transaction Decoder?

The Ethereum Transaction Decoder takes a raw signed transaction in hex and pulls it apart field by field. It handles legacy transactions (with the EIP-155 chain ID worked out from v) and the EIP-2718 typed envelopes: 0x01 access-list, 0x02 EIP-1559, 0x03 blob and 0x04 set-code transactions. You get the transaction hash, chain, nonce, recipient, value in ETH and wei, gas limit, fee fields, the maximum possible gas cost, the access list and the signature values.

If the input data starts with a common ERC-20 or ERC-721 selector (transfer, approve, transferFrom, safeTransferFrom, setApprovalForAll), the arguments are decoded too. Anything else shows the 4-byte selector and raw calldata, ready to paste into the Smart Contract ABI Decoder with the contract's ABI.

Decoding happens in your browser with no node or API, which also sets its limits. A 32-byte transaction hash cannot be decoded, because the hash does not contain the transaction; the tool tells you so and gives an Etherscan link. It also does not recover the sender address, which needs secp256k1 public key recovery from the signature.

  • Legacy, EIP-2930, EIP-1559, EIP-4844 and EIP-7702 formats
  • Transaction hash computed with Keccak-256
  • Chain ID from EIP-155 v or the typed payload
  • ERC-20 and ERC-721 calldata decoding
  • Strict RLP checks with clear errors
  • Runs in your browser, no node or API calls
Read the guide: Decoding Ethereum Transactions: RLP, Selectors and ABI Calldata

Updated

How to use the Ethereum Transaction Decoder

  1. Get the raw signed transaction: wallets and signing libraries show it as the serialized or raw transaction, and eth_getRawTransactionByHash returns it from a node.
  2. Paste the hex into the Raw Transaction field. The 0x prefix is optional.
  3. Press Decode Transaction.
  4. Read the Transaction Details card. Check the chain ID, recipient, value and max gas cost before broadcasting anything you did not build yourself.
  5. Use Copy to take the report, or copy the raw input data into the Smart Contract ABI Decoder for a full decode.

Worked examples

The EIP-155 reference transaction

Input

0xf86c098504a817c80082520894353535...3535880de0b6b3a76400008025a028ef...6276a067cb...6d83 (the full signed example from EIP-155)

Output

Type 0 (Legacy), chain ID 1 (Ethereum mainnet), nonce 9, gas price 20 gwei, gas limit 21000, value 1 ETH, to 0x3535353535353535353535353535353535353535, v 37, max gas cost 0.00042 ETH

v = 37 is 1 x 2 + 35, so the chain ID is 1. With empty input data this is a plain ETH transfer, which is why the gas limit is exactly 21,000.

Pasting a transaction hash by mistake

Input

A 66-character 0x hash

Output

A note that this is a hash, plus an Etherscan link for it

Hashes identify transactions but carry none of their fields. You need the raw signed bytes, or an explorer that looks the hash up on chain.

Background and insight

A legacy Ethereum transaction is an RLP list of nine items: nonce, gasPrice, gasLimit, to, value, data, v, r and s. RLP (Recursive Length Prefix) only knows byte strings and lists, so integers are big-endian with no leading zeros and an empty string means zero or, for to, contract creation. EIP-155 (2016) put the chain ID into v as chainId x 2 + 35 or 36 to stop a signed transaction being replayed on another chain; a v of 27 or 28 means the transaction predates that protection.

EIP-2718 (Berlin, 2021) introduced typed transactions: a single type byte below 0x80 followed by a type-specific payload. Type 1 (EIP-2930) adds an access list. Type 2 (EIP-1559, London) replaces gasPrice with maxPriorityFeePerGas and maxFeePerGas. Type 3 (EIP-4844, Dencun 2024) adds blob fields, and type 4 (EIP-7702, Pectra 2025) adds an authorization list. A raw value starting with 0x02 is a type 2 transaction; one starting with 0xf8 or 0xf9 is an RLP list, so legacy.

The transaction hash shown on explorers is Keccak-256 over exactly these raw bytes, including the type byte. That is why changing anything, even re-signing with the same fields, produces a different hash, and why the hash is a fingerprint rather than a container.

Common use cases

  • Checking a transaction before broadcast

    Confirm the chain ID, nonce, recipient, value and fee caps of a signed transaction from a script or hardware wallet before sending it.

  • Debugging a stuck nonce

    Decode two pending transactions to see which nonce each uses and whether the replacement really pays a higher tip.

  • Reviewing multisig or relayer payloads

    See what a raw transaction handed to you by a service will actually call, including ERC-20 approve amounts.

  • Learning RLP and typed transactions

    Compare a legacy, type 1 and type 2 transaction to see how fields change between them.

Tips and limitations

  • An approve with an amount of 115792089237316195423570985008687907853269984665640564039457584007913129639935 is an unlimited approval (2^256 - 1).
  • If the chain ID line says "not set", the transaction is pre-EIP-155 and could be replayed on any chain that accepts it.
  • For type 3 blob transactions the decoder reads the transaction part only; the blobs themselves are not shown.
  • The sender is not displayed. Explorers derive it from the signature; do not assume who signed from the raw bytes alone.
  • Value and fees are shown in ETH, but the same units apply on Polygon, BNB Chain and rollups with their own native token.

Sources and further reading

  1. Recursive-length prefix (RLP) serialization, Ethereum Foundation
  2. EIP-155: Simple replay attack protection, Ethereum Improvement Proposals. Chain ID in v
  3. EIP-2718: Typed Transaction Envelope, Ethereum Improvement Proposals
  4. EIP-4844: Shard Blob Transactions, Ethereum Improvement Proposals. Type 3 transactions
  5. EIP-7702: Set Code for EOAs, Ethereum Improvement Proposals. Type 4 transactions

Frequently asked questions

How do I decode a raw Ethereum transaction?

Paste the signed transaction hex into the Raw Transaction field and press Decode Transaction. The tool reads the type byte, decodes the RLP payload and lists each field with values in ETH and gwei. Legacy and typed transactions (0x01 to 0x04) are supported.

Can I decode an Ethereum transaction from its hash?

Not offline. A transaction hash is the Keccak-256 of the signed bytes, so the fields cannot be recovered from it. Look the hash up on a block explorer, or fetch the raw bytes with eth_getRawTransactionByHash from a node and paste them here.

What does the first byte of a raw transaction tell me?

It tells you the transaction type. 0x01 is an EIP-2930 access-list transaction, 0x02 is EIP-1559, 0x03 is an EIP-4844 blob transaction and 0x04 is EIP-7702. A first byte of 0xc0 or above, usually 0xf8 or 0xf9, is a legacy RLP list.

How is the chain ID stored in a legacy transaction?

It is folded into the v value as chainId x 2 + 35 or + 36, as defined by EIP-155. So v = 37 means mainnet (chain 1) and v = 310 means Polygon (chain 137). A v of 27 or 28 has no chain ID at all.

Why is the from address not shown?

Ethereum transactions do not contain a from field. The sender is recovered from the r, s and v or yParity signature values using secp256k1 public key recovery, which this tool does not implement. A node or explorer will show the sender once the transaction is known.

Is it safe to paste a signed transaction here?

Decoding is local, so the transaction is not sent anywhere by this page. Keep in mind that a signed transaction is ready to broadcast: anyone who obtains it can submit it, though they cannot change it. It never contains your private key.

Is there an in-depth guide to the Ethereum Transaction Decoder?

Yes. “Decoding Ethereum Transactions: RLP, Selectors and ABI Calldata” covers the background, how it works, common pitfalls and worked examples. Read the full guide.