Ethereum blob fees: a separate bill from execution gas

Explainer7 min read

Calculate Ethereum blob and execution fees from separate receipt fields. Follow a fictional L1 example, Fusaka pricing limits and the boundary with an L2 user bill.

Fictional Ethereum L1 fee illustration: Brokzi compares an orange execution-gas receipt and a mint blob-data receipt over one transaction dossier containing an execution path and two blob packets.
AI-assisted editorial illustration · Brokzi
On this page

An Ethereum blob-carrying transaction can have two fee components. An explorer's execution-gas figure may show only one of them. Multiplying that figure by a price labelled simply "gas" can leave part of the bill unexplained.

For an Ethereum blob fee versus gas fee comparison, start with the transaction and its network. This article reads one L1 blob transaction, separates its two resource charges and works through an invented receipt. A rollup user's L2 transaction is a different accounting task.

One L1 transaction, two resources

EIP-4844 introduced type-3, or blob-carrying, transactions. They retain execution-gas fields and add a separate blob fee cap and references to the blobs they carry.

Execution gas accounts for processing the transaction, including its contract execution. Blob gas accounts for the attached blob data under Ethereum's data-availability rules. Blobs give rollups a way to publish data that others need to verify their state. Availability does not mean permanent archival storage, as the data-availability documentation explains.

The EVM cannot directly read a blob's full contents. EIP-4844 provides access to versioned hashes and a proof-verification mechanism instead. Paying execution gas therefore does not buy an unlimited amount of blob data inside the same allowance.

For an included L1 blob transaction, calculate the two fee components separately, then add their ETH amounts. Keep any ETH value transferred by the transaction outside that fee calculation.

Match each receipt field to its unit

The Ethereum execution API receipt schema distinguishes individual execution usage from individual blob usage. It specifies the two blob fields for EIP-4844 blob transactions.

Receipt fieldUnitWhat it describes
gasUsedExecution gasAccounted execution usage of this transaction
effectiveGasPriceWei per execution gasActual execution unit price charged
blobGasUsedBlob gasBlob usage of this transaction
blobGasPriceWei per blob gasActual blob unit price charged

The receipt calculations are:

  • Execution fee: gasUsed × effectiveGasPrice.
  • Blob fee: blobGasUsed × blobGasPrice.
  • Combined L1 fee: execution fee plus blob fee, expressed in the same currency unit.

Do not add execution-gas units to blob-gas units before multiplying. They measure different resources. The resulting fees can both be expressed in wei, gwei or ETH; Ethereum's gas documentation defines 1 gwei as 10⁹ wei, or 10⁻⁹ ETH.

Also check which record you opened. Receipt cumulativeGasUsed includes this transaction and earlier transactions in the same block. A block's blobGasUsed is an aggregate for the block. Neither is a substitute for this transaction's individual usage. Our receipt, event and trace guide explains why different explorer views answer different questions.

Example A: two blobs and a separate execution charge

Example A is fictional. Assume one included Ethereum L1 type-3 transaction carrying two blobs. These are decimal worksheet values, not a complete JSON-RPC response, an observed transaction or today's fee rates. No node or wallet was used to produce them.

EIP-4844 assigns 131,072 blob gas per blob. For this example, two blobs therefore use 2 × 131,072 = 262,144 blob gas. Blob gas follows the blob count, rather than a meter that discounts each unused byte inside a blob.

Assume final gasUsed of 50,000 execution gas, an effectiveGasPrice of 12 gwei per execution gas, and a blobGasPrice of 1 gwei per blob gas. Final execution usage is taken as given after applicable gas accounting; we have not simulated a contract.

Fee componentFictional calculationResult in ETH
Execution50,000 execution gas × 12 gwei per execution gas = 600,000 gwei0.0006 ETH
Blobs262,144 blob gas × 1 gwei per blob gas = 262,144 gwei0.000262144 ETH
Combined L1 fee600,000 gwei + 262,144 gwei = 862,144 gwei0.000862144 ETH

Reading only the execution multiplication would omit 0.000262144 ETH in this example. Conversely, adding an explorer's already combined total to the blob fee would count the blob component twice. Establish what its displayed total includes before reconciling it.

Fee caps do not replace the receipt prices

A type-3 transaction has an execution maxFeePerGas and a separate maxFeePerBlobGas. Both are ceilings offered by the sender, not evidence of the price ultimately charged.

If Example A had a blob fee cap of 3 gwei per blob gas, its assumed actual blob price would still be 1 gwei. Multiplying usage by the cap would calculate a ceiling rather than the settled blob fee. The blob cap must cover the applicable blob base fee for inclusion.

The blob charge described by EIP-4844 is burned; it has no separate blob-priority-fee field. The transaction's execution component can still include an execution priority fee. For execution caps, tips and unused allowance, use the gas-limit versus gas-price explainer.

Separate accounting does not mean fully independent prices

Early EIP-4844 explanations describe a separate blob fee market. That distinction remains useful, but it is incomplete as a statement about how today's price adjustment works.

Ethereum's Fusaka guide records the upgrade's activation on December 3, 2025, and its inclusion of EIP-7918. That EIP links the blob reserve-price mechanism to the execution base fee. When its reserve comparison is triggered, the blob excess-gas update changes so the fee can rise toward the reserve instead of continuing to fall in the usual way.

This is an adjustment mechanism, not a promise that the blob price instantaneously equals a fixed multiple of the execution price in every block. EIP-7918 explicitly discusses a possible delay after a quick rise in execution fees. The two receipt multiplications still use their respective actual prices.

Blob targets, maximums and fee-update parameters are also fork-specific. EIP-7840 defines a blob schedule; EIP-7892 supports blob-parameter-only forks. The original EIP-4844 capacity table is historical context, not a reliable current-capacity lookup. No live capacity or price measurement is used here.

A failed execution does not erase the blob charge

For an included blob transaction, EIP-4844 deducts and burns the blob fee before execution. It says that fee is not refunded if transaction execution fails. A reverted contract action therefore does not, by itself, make the attached blob publication free.

That statement concerns an included transaction. A pending lookup, rejected submission or local wallet error does not establish the same charge. Ethereum's JSON-RPC overview notes that pending transactions have no receipt. Our failed-transaction gas guide owns the distinction between rejection, revert and out-of-gas.

An L2 user's bill is a different record

A rollup can publish a batch of data to Ethereum through an L1 blob transaction. Its publisher incurs the L1 costs of that transaction. An individual user's transaction on the rollup has its own L2 receipt and the network's fee rules.

You cannot take Example A's L1 sum and assign it to one L2 user merely because that user's activity contributed data to a batch. Nor does dividing the batch cost by a transaction count establish the user charge: compression, allocation and the rollup's pricing rules matter. The Layer 2 explainer covers that wider relationship.

An ordinary L1 type-2 ERC-20 transfer is not itself a type-3 blob transaction and does not acquire its own blob charge just because rollups use blobs. If a view omits blob fields, identify the transaction type, network and provider's schema first. An incomplete display is not enough evidence to declare a blob transaction's fee zero.

When checking a bill, keep the network, transaction type, individual receipt fields and units together. Reconcile the two L1 components for a blob transaction, then consult the specific rollup's current documentation if the question is an L2 user charge.

Sources

Primary sources checked October 29, 2026, Asia/Tbilisi. The accounting example is invented, not a live fee quote or transaction test. No RPC request, wallet connection, signing, simulation or transaction was performed. Historical specifications are read alongside Fusaka-era changes; scheduled values and illustrative fork configurations are not presented as current measurements.

See something wrong? Brokzi logs material changes. Prepare a correction note.

About the byline

Brokzi Editorial

The accountable byline for Brokzi’s explainers, definitions, news notes, and corrections.

Editorial responsibility →