You open an old Ethereum transaction. The block is there, the transaction has a result, and the page lists a blob reference. Yet the data you wanted is nowhere in that view.
That is a reason to identify what the page actually supplies before diagnosing a broken chain. An Ethereum blob transaction record and its full blob data are different objects. A versioned reference identifies the relevant commitment; it is not a download link, and a fee record is not an archive subscription.
This explainer maps those objects and the evidence needed for historical retrieval. It does not calculate fees, test a provider or establish today's network-wide storage window.
What remains in the transaction record?
EIP-4844 defines a blob-carrying transaction with ordinary execution fields, a blob fee cap and a list called blob_versioned_hashes. Its execution-payload representation does not contain the full blobs. The specification separates that representation from network messages carrying the accompanying data.
A transaction can also have an ordinary data field, often called input or calldata. The presence of that field does not turn it into the transaction's attached blobs. Reading input bytes and obtaining blob bytes are different tasks.
The receipt describes the execution outcome and associated records. A useful explorer can combine receipt fields, transaction fields and extra data from its own infrastructure on one page. That presentation does not make all those objects part of the receipt, or demonstrate that the explorer retains every historical blob.
Our Ethereum receipt, event and trace explainer covers those execution views. For this question, keep the boundary simple: a visible execution record can describe a blob transaction without delivering its blob contents.
| Object | What it contributes | What it does not supply by itself |
|---|---|---|
| Execution transaction | Transaction fields, including the blob's versioned reference | The full attached blob data |
| Execution receipt | Outcome and execution-related records | A historical blob download |
| Blob commitment and versioned reference | A cryptographic relationship used to identify and check the relevant data | A provider address or promise of continued storage |
| Actual blob data | The separately supplied contents needed for the blob-data task | Evidence that this copy matches the expected reference unless the relevant checks are made |
| Retention and retrieval arrangement | Evidence about who keeps and serves the needed data | A guarantee inferred merely from an execution record |
The table describes roles. It is not a catalogue of fields that every explorer must display.
A versioned hash is a reference, not a download address
The EIP derives a versioned hash from a blob's KZG commitment. A commitment is a compact cryptographic object that allows checks concerning the data it commits to. It is not a compressed archive from which a reader can unpack the complete original blob.
EIP-4844 gives the EVM access to versioned hashes through BLOBHASH. It also defines a point-evaluation precompile that checks a supplied claim and proof against the relevant commitment and versioned hash. Neither mechanism means that execution can directly read an entire blob.
Those are verification relationships, not delivery instructions. The reference does not contain the name of an archive provider, the provider's historical coverage or the terms under which it keeps data. Even a successful check of one supplied point is not the same operation as obtaining the whole blob.
No commitment or proof was checked for this article. The distinction matters when reading a claim such as “the hash is still onchain”: that may identify the expected data, while leaving its present location and retrieval unresolved.
Availability then and retrieval later answer different questions
Ethereum.org's data-availability documentation distinguishes the data needed for verification from the ability to retrieve historical information later.
For blobs, EIP-4844 deliberately separates data availability from the long-term retention of execution history. Its original design places blob persistence for availability on the consensus side, rather than requiring the execution layer to keep the full blobs as part of its execution payloads.
That architecture explains why an old transaction lookup and an old blob lookup can have different answers. It does not establish the precise retention behavior of a current client, network upgrade or service. A page's publication date, a protocol's original parameter table and a provider's present storage policy are different evidence.
In particular, do not turn an early specification's retention value into a universal deletion deadline. A minimum protocol requirement would not, by itself, prove that every operator deletes its copy immediately afterward. Nor would it promise that every reader can obtain a copy forever.
An “archive” label needs the same care. Keeping historical execution state or serving old transaction receipts does not, from that label alone, establish storage of the separately distributed blob data. Ask which data the service actually retains.
A fictional record-and-retrieval case
Imagine Example E, a teaching case involving an Ethereum L1 blob transaction. Transaction T, Block B, Reference R and Provider P are invented labels, not real hashes, operators or observations. There is no live request behind this example.
Suppose an execution view shows Transaction T in Block B and lists Reference R. A reader wants the full blob associated with R. Consider these separate, hypothetical observations:
| Observation in Example E | What the observation supports | What still needs evidence |
|---|---|---|
| The execution view returns T and lists R | That this view supplies that execution record and reference | Where the corresponding blob data can be obtained now |
| P documents historical receipt access but says nothing about blobs | A claim about receipt access | Whether P retains and serves this blob-data class for B |
| A historical blob request to P produces no usable response | That this attempt did not supply the required data | The cause, P's coverage and whether another retained copy exists |
| A separate service supplies data claimed to correspond to R | That data was delivered under that claim | Whether the data and required verification evidence match the expected context |
These rows are possible observations, not a sequence guaranteed to succeed. There is no inference here that switching providers will recover missing data. A service has to possess or obtain a suitable retained copy; a different hostname cannot create one.
The useful result may simply be a well-bounded unknown: “This provider did not supply the blob for this block in this request context.” That statement carries more information, and less speculation, than “Ethereum lost the transaction.”
What a historical blob claim needs to specify
Before relying on a statement that old blob data is available, look for evidence answering five questions:
- Which record? Identify the network, block, transaction and relevant blob reference. A transaction can refer to multiple blobs, so the transaction identifier alone may not identify which data is being discussed.
- Which data class? Does the service describe full blob data, execution history, receipts or only references? Similar-looking history features are not interchangeable.
- Which provider and coverage? What does the named service say it retains and serves for the relevant historical context? Keep its documented coverage separate from Ethereum's protocol requirements.
- Which observation? Distinguish a documented capability from an actual response at a particular time. If an attempt failed, record the narrow result without assigning an unverified cause.
- Which verification? If bytes were supplied, what evidence ties them to the expected blob reference and block context? A file labelled with a transaction hash is a claim about that relationship, not the completed check.
This is a checklist for reading documentation and evidence, not an instruction to run a node, call an API or upload data. It does not identify a recommended storage provider. Where a field lacks support, leave it unknown.
What a missing historical response cannot tell you
One unsuccessful retrieval does not show that the data was unavailable when the block was originally verified. It also does not establish that every retained copy has disappeared. Those are claims about different times and a much wider scope than one response.
Likewise, it does not diagnose a finality failure, invalidate the original transaction or show that an account balance has been lost. Those questions need their own evidence. A historical data-access problem should not quietly become a claim about funds.
The inverse shortcut fails too: a successful historical download does not promise permanent future service. Describe the data, provider, time and verification actually supported by the evidence, rather than turning one result into a lifetime guarantee.
Does paying a blob fee buy permanent storage?
No. A blob fee accounts for the transaction's use of the blob resource under the applicable protocol rules. It does not itself create a perpetual archival service for that sender or every future reader. The blob-fee and execution-gas article explains the two separate L1 charges and how to account for them.
If your question concerns a rollup, separate its own transaction history, the relevant Ethereum publication and the data that a particular task needs. Our Layer 2 explainer covers execution, settlement and withdrawal paths. A missing response from one historical blob service is not, by itself, a diagnosis of any specific rollup's current condition.
For Ethereum blob data, the next useful question is concrete: what object do I need, and what evidence shows that this provider can supply and verify it for this historical context? The execution record is the starting point for that investigation, not the storage arrangement itself.
Sources and scope
Primary documentation captured and checked on 22 November 2026. EIP-4844 is a Final specification created on 25 February 2022. Its original design is used here to explain the separation of references, execution records and blob data, not as a complete specification of the currently deployed fork.
Ethereum.org is living documentation. Its displayed page-update date is not evidence of a network activation or client release. This article does not assert a current universal retention duration, blob capacity, deployed sampling mechanism or provider guarantee.
No live blob retrieval, RPC request, node operation, proof verification, storage upload, wallet connection, signature or transaction was performed. Example E and the illustration are fictional explanatory devices.
- EIP-4844: Shard Blob Transactions — transaction representations, versioned references, EVM access, proof checks and the separation of blob persistence from execution history.
- Ethereum.org: Data availability — the distinction between availability for verification and historical data retrievability; not a current provider service-level promise.
See something wrong? Brokzi logs material changes. Prepare a correction note.




