Summary: This is your go-to guide for understanding Etherscan’s View Blobs page and how proto-danksharding, Pectra, and the upcoming PeerDAS era are changing the game for Ethereum’s data approach, costs, and how we observe things for L2s and enterprise developers. We’ll break down the specs into checklists, formulas, and the latest best practices that you can start using right away.

Understanding https://etherscan.io/txsBlobs and the Future of Ethereum Data

If your product relies on Ethereum data availability--like if you’re running an L2, submitting batched proofs, or auditing counterparties--blobs are now a must-have, not just some optional backend stuff. They’ve become a key cost center and a real-time operational signal for your project. In this post, we’ll break down how to navigate Etherscan’s “View Blobs” page, dive into how blob fees are actually calculated, and discuss what shifted after Pectra. Plus, we’ll touch on what PeerDAS and the parameter-only “BPO” forks mean for your plans in 2026. We’ve also included practical examples and a handy checklist for you and your team to dive into this week.

The 60‑second refresher: what a “blob” is (with exact numbers)

• So, a blob is basically a chunk of temporary data that’s around 128 KiB, introduced by this new Type‑3 transaction in EIP‑4844 (yep, that’s proto‑danksharding). Each blob consists of 4,096 field elements, and since each element is 32 bytes, that adds up to 131,072 bytes. You can spot these blobs being referenced in transactions through versioned hashes, and right now, the version byte is set to 0x01. You can read more about it here.
• Blob storage is hooked up to the consensus layer (that’s the beacon chain for you) and gets pruned after about 4,096 epochs, which is roughly 18 days. For anything that needs to stick around, there’s a KZG commitment keeping it safe in the canonical history. More details are available here.
• When it comes to blobs, they operate on their own EIP‑1559-style fee market, known as “blob gas.” This means they have a unique base fee and can be adjusted based on elasticity. Before the Pectra phase, the goal was to target 3 blobs per block, with a max cap of 6. Check out more on this here.

Why it matters: Blobs are coming in at a much lower price compared to calldata for data-heavy tasks. Plus, they aren’t readable by the EVM, which is exactly what rollups need for batching posts. Check out more details here: (info.etherscan.com)

---

A guided tour of Etherscan’s “View Blobs” page

Just head over to Etherscan's blob transactions page, and you’ll get a real-time look at the blob sidecars that are linked to mainnet transactions. Here are the columns you’ll want to check out: (etherscan.io)

• Blob Versioned Hash: This is the 32-byte identifier for a blob's commitment hash with a version prefix. You can use it to cross-reference external archives or your own storage. (eips.ethereum.org)
• Transaction Hash: This refers to the L1 Type‑3 transaction that carries one or more blobs.
• Block and Timestamp: This tells you where and when the blob got included on L1.
• Blob Sender: On Etherscan, this is the label for the submitter, which could be something like "Base: Batch Sender," "Arbitrum Batch Poster," or "Blast: Batch Sender." It's super helpful for keeping an eye on your competitors and counterparties. (goto.etherscan.com)
• Gas Price: Here you’ll find the gas price for the transaction. For blob economics, make sure to focus on the blob fee terms rather than just the regular gas line. (etherscan.io)
• Size: Each blob on mainnet is always 128 KiB. Keep in mind that senders have to pay for the full blob even if it’s not completely filled. (eips.ethereum.org)
• Excess Blob Gas: This shows you a snapshot of the EIP‑1559 "excess" running counter that’s used to calculate the blob base fee. When this number is high, you can expect the base fee per blob gas for the next blocks to trend upward. When it’s low or negative, it tends to trend downwards. (eips.ethereum.org)

Tip: If you check out the Blocks page on Etherscan, you’ll see blob counts for each block right there. Plus, their info center gives you the latest blob gas price from the same “View Blobs” page. You can find all that info at (info.etherscan.com).

---

Fees: the exact formula you should budget against

Blob transactions incur two separate fees:

• Calldata/EVM Fee: This is calculated the usual way by taking gasUsed and multiplying it by the effective gas price. Just a heads up, there’s a new calldata repricing due to EIP‑7623 (you can find the nitty-gritty details below). Check it out here: (eips.ethereum.org).
• Blob Fee: This one’s a bit tricky because it gets burned and isn’t refundable, even if the transaction doesn’t go through. It’s calculated as blobGasUsed multiplied by baseFeePerBlobGas, but it’s capped by maxFeePerBlobGas. Remember, each blob brings in GAS_PER_BLOB, which equals 2^17 blob gas. More info here: (eips.ethereum.org).

In terms that feel a bit like code (thanks to EIP-4844):

blob_fee = get_total_blob_gas(tx) * get_base_fee_per_blob_gas(header)
get_total_blob_gas(tx) = GAS_PER_BLOB * number_of_blobs
GAS_PER_BLOB = 2**17

The base fee for each blob gas update follows a “fake exponential” model that relies on excess_blob_gas, much like the mechanics seen in EIP‑1559 (with a variation of around 12.5% pressure compared to target utilization). That’s why you’ll find “Excess Blob Gas” on Etherscan to be a valuable leading indicator. Check it out here: (eips.ethereum.org)

Practical Budgeting Example:

Let’s break down a simple budgeting example to see how it all comes together.

Monthly Income

First up, let's take a look at the monthly income. Here’s a quick snapshot:

So, our total income for the month comes out to $4,000. Not too shabby!

Monthly Expenses

Now, let’s look at the expenses. Here’s how the budget typically shakes out:

This brings our total monthly expenses to about $3,050.

Budget Summary

Now, let’s do some simple math to see how much we’ve got left over:

• Total Income: $4,000
• Total Expenses: $3,050
• Remaining Balance: $4,000 - $3,050 = $950

So, at the end of the month, you’re looking at a sweet $950 leftover! This can be set aside for savings, investments, or maybe a little fun.

Final Thoughts

Budgeting doesn’t have to be a drag. It’s all about making sure you know where your money's going and having a plan for it. Whether you’re saving for a trip or just trying to make ends meet, keeping track of everything can really help. Happy budgeting!

• Let’s say the base fee per blob gas is set at 1 gwei and your batcher happens to post 4 blobs per slot.
• So, the cost breakdown for a single blob would look like this: 131,072 blob gas × 1 gwei = 131,072 gwei, which equals about 0.000131072 ETH.
• When you scale that up to four blobs, you’re looking at around 0.000524288 ETH for each post (not counting the EVM gas). If you’re posting every slot, which is roughly every 12 seconds, that adds up to about 0.00394 ETH per minute at a 1 gwei base fee. Just remember to check your actual base fee on Etherscan for the most accurate numbers. (eips.ethereum.org)

A Couple of Sneaky Gotchas for CFOs and SREs

Here are two things that might trip up CFOs and SREs if they're not careful:

1. Budgeting for Downtime
   Think you’re safe with your uptime guarantees? Well, remember that downtime can hit your wallet. Whether it’s scheduled maintenance or unexpected outages, you’ll need to factor in the financial impact. Keep an eye on your Service Level Agreements (SLAs) -- they might just save you from some nasty surprises.
2. Compliance Costs
   Compliance isn’t just a checkbox; it can be a hefty expense. From security measures to audits, the costs can pile up quickly. CFOs, make sure you’re collaborating closely with your SREs to understand these requirements. It’ll save you both money and the headache of scrambling to meet regulations last minute.

By keeping these in mind, you can navigate your roles a little smoother!

• You’re charged for the full 128 KiB for each blob, even if you don’t use all of it, so it's a good idea to pack those batches tightly. Check it out here: (blocknative.com)
• Just a heads up, blob fees get burned no matter if the execution succeeds or not. So, steer clear of strategies that could lead to a post‑inclusion failure. More details can be found here: (eips.ethereum.org)

---

What changed in 2025: Pectra doubled blob capacity and nudged DA off calldata

Ethereum rolled out the Pectra upgrade on May 7, 2025, and it brought along EIP‑7691. This change upped the blob target from 3/6 to 6/9 per block, which is pretty significant. As a result, the daily blob data availability (DA) capacity jumped from around 5.5 GB to about 8.15 GB. This boost helped reduce the pricing pressure during those high-demand times. For a lot of Layer 2 solutions, posting costs dropped and managed to hang around the new target for a good while. You can check out more details about it here.

At the same time, EIP‑7623 raised the base cost for calldata in data-heavy transactions. This helps keep the worst-case block size in check and shifts some of those data availability (DA) workloads to blobs. Think of calldata as a kind of pressure relief valve during busy times, rather than your go-to option. If your setup is still depending on calldata for DA, make sure to adjust for the new base price and check that your wallets and estimators are up to date. (eips.ethereum.org)

Observed Market Impact (Aggregated Research Snapshots):

Here’s a look at the overall market impact based on our collected research snapshots:

• After Pectra, research desks noticed that rollup DA costs dropped and blob utilization was below target in several epochs--this aligns with the base fee staying low. Just a heads up, node bandwidth and storage pressure increased since more blobs stuck around in the 18-day retention window. Keep this in mind when you’re running validators. (galaxy.com)

---

How to use Etherscan blobs data in day‑to‑day operations

1. Keeping an Eye on Prices and Posting Windows

• Make sure to bookmark View Blobs and keep an eye on the “Excess Blob Gas” as it moves through consecutive blocks. If you notice it trending down or staying level near your target, it might be a good time to push your posting window forward. On the flip side, if it’s trending upwards, it’s a smart move to compress more aggressively to cut down on blobs/slot. If you want to be super responsive, think about automating this with your own monitors. (etherscan.io)

2) Counterparty Observability

• To get a better grip on how competitors are operating, you can filter the rows labeled “Blob Sender” with names like “Base: Batch Sender” or “Blast: Batch Sender.” This little trick helps you analyze competitor frequency, blob packing efficiency, and posting timelines. It’s a quick way to check out market behavior without diving into a full-blown analysis. You can check it out here: (goto.etherscan.com)

3) Forensics and Audits

• Make sure to grab the “Blob Versioned Hash” and keep it in your archive for accessing payloads that you’ve stored off-protocol. Even after about 18 days, that KZG commitment allows you to check a payload’s integrity against the official history. Etherscan’s info center helps out by clarifying that while blob data gets pruned on-chain, it’s still provable off-chain. You can read more about it here.

4) API Planning

• So, Etherscan’s API v2 doesn't have a dedicated “blob list” endpoint just yet. However, if you want to get creative, you can combine block data, transaction type (0x03), and the blob counts found on the page to create some straightforward dashboards. Just a heads-up: Etherscan advises everyone to switch to API v2 since V1 will be turned off after May 31, 2025. Check it out here: (etherscan.io).

---

• Find a low-fee window:
  • What to look for: Keep an eye on Excess Blob Gas staying flat or dropping for at least 10 blocks, and make sure the baseFeePerBlobGas is close to the minimum.
  • What to do: Bump up your batch size to match your latency SLO, aiming for 5-6 blobs per transaction to keep those per-transaction costs down. Just remember to check that it’s full; you still need to pay for the entire 128 KiB. (blocknative.com)
• When the blob market starts heating up:
  • What to keep an eye on: Watch for Excess Blob Gas rising sharply and your estimated base fee hitting your internal limit.
  • Action: Flip the switch to "tight packing" mode: go for more aggressive compression and cut down on the number of L2 blocks per blob. If necessary, think about temporarily falling back to calldata--but only if your total cost model (with the EIP‑7623 floor) is better than the blob fee. This is pretty rare after Pectra, but it's worth modeling it out explicitly. (eips.ethereum.org)
• SLA for data retention:
  • What to keep an eye on: Compare how well your internal archives stack up against the on-chain pruning timeline, which is roughly 18 days.
  • What you should do: Make sure to save those important blobs you don't want to lose (think regulatory stuff or settlement recon) in an off-protocol archive that's keyed by versioned hash. You can verify integrity based on the commitment in the L1 history. Check it out here: (eips.ethereum.org)

---

Emerging best practices we’re seeing work

• Blob-first posting policy using calldata as a pressure valve
  • Establish a rule: “Post to blobs unless the anticipated blob fee is greater than X for Y consecutive slots.” Keep an eye on X and adjust it as capacity increases with the new parameters. (eips.ethereum.org)
• Pack it tight to those 128 KiB boundaries
  • Organize those batchers to fill up those blobs--there's no point in sending out 80-90 KiB blobs when you could just combine them. It won't cost you any extra. (blocknative.com)
• Make sure to use EIP‑7623-aware estimators and wallets
  • Keep in mind that gas estimation needs to consider the calldata floor; otherwise, you might end up underpricing transactions, which can lead to failures. A few teams ran into this issue right after it went live. (eips.ethereum.org)
• Keep an eye on blob supply signals rather than just the price.
  • Create a straightforward time series for both excess_blob_gas and blobs_per_block. Remember, price often lags behind; you can spot supply pressure early through utilization and excess counters. For a quick human check, Etherscan’s Blocks page is super handy. (info.etherscan.com)
• Archive and attest
  • Since blobs get pruned on-chain, you’ll want to either maintain your own archive or use a third-party service. Verification is still trust-minimized thanks to KZG. (info.etherscan.com)

---

What’s next: PeerDAS, BPO forks, and faster capacity increases

• PeerDAS (EIP‑7594) is making its debut in the 2025 “Fusaka” upgrade, with the mainnet activation set for December 3, 2025. This update brings in data availability sampling, which means nodes will only need to verify parts of blob data. This should allow for higher blob throughput without needing super high-end hardware, easing the bandwidth demands on each node as blob counts increase. You can read more about it here.
• The Blob Parameter Only hard forks (EIP‑7892) are all about those "BPO" bumps--these are light adjustments that tweak blob targets and maximums, making it easier for Ethereum to ramp up blob capacity more often and safely as PeerDAS settles in. So, get ready for changes in capacity to happen more regularly than the usual timeframe of 2024-2025. Check it out here.
• After the Pectra upgrade, the community has already boosted the target and max to 6/9 through EIP‑7691 and is eyeing even more increases in 2026 once the PeerDAS data stabilizes. Expect those capacity bumps to be more gradual rather than huge jumps. More details can be found here.
• And don’t forget about the fee market adjustments! Proposals like EIP‑7762, which aims to raise MIN_BASE_FEE_PER_BLOB_GAS, are out there to help with price discovery, so keep an eye on them if you’re working with tight margins. You can check it out here.

Bottom line: the medium-term roadmap is looking good with more blob supply, smoother price discovery, and a quicker way to adjust capacity changes. This is definitely a win for L2 economics and end-user fees. (eips.ethereum.org)

---

Deep‑dive: exact limits and retention (pin these for onboarding)

• Size per blob: Each blob is 128 KiB, made up of 4,096 field elements that are 32 bytes each, all built around the BLS12‑381 scalar field. (eips.ethereum.org)
• GAS_PER_BLOB: That’s 2^17 blob gas. (eips.ethereum.org)
• Retention: Blobs stick around for 4,096 epochs, which is about 18 days on consensus-layer clients, but they get pruned after that. Just keep in mind that KZG commitments stay in history for good. (eips.ethereum.org)
• Pre‑Pectra capacity: We're aiming for a target of 3 blobs with a max of 6 per block, but after Pectra rolls out, the goal shifts to 6 blobs with a max of 9. (eips.ethereum.org)
• Calldata repricing: With EIP‑7623, the baseline for data-heavy transactions is raised to help ease up on worst-case block sizes. If you're still relying on calldata for data availability, it might be worth your time to rerun those cost models. (eips.ethereum.org)

---

For decision‑makers: a quick ROI framework

1. Figure Out DA Demand

• Start by checking out your average compressed batch size for each L2 block and how many L2 blocks you’re posting for every L1 slot. From there, convert that into blobs per slot, making sure to add a 10-15% buffer to handle any unexpected spikes.

2) Model at Two Price Points

• Start with a conservative blob base fee, like 3-5 gwei, and then set a stress price between 10-20 gwei to create a cost band. The formula you use here is pretty straightforward; just grab the real-time base fees from Etherscan’s page while you're working. (etherscan.io)

3) Decide Your Survivable Latency

• Keep in mind that lower fees often result in bigger batches and a bit of a delay in finality. Start by establishing your product's Service Level Objectives (SLOs), then pinpoint where the best trade-off is on the curve.

4) Architecting for Parameter Changes

• Make blob capacity flexible. With the PeerDAS update and the introduction of BPO forks, we should anticipate more regular increases in target/max values without needing to overhaul everything. So, it's a good idea to incorporate adjustable controls in your batcher to handle when the network shifts from something like 6/9 to a higher target. Check it out here: (eips.ethereum.org)

---

Implementation checklist (steal this)

• Posting pipeline
  • We’re sticking with blobs by default and packing them to 128 KiB. Oh, and the retries will respect those baseFeePerBlobGas ceilings.
  • We’ve got a calldata fallback that kicks in behind a circuit-breaker, keeping EIP-7623 economics in mind. (eips.ethereum.org)
• Monitoring
  • We're setting up alerts for excess_blob_gas and blobs_per_block trends, not just the spot prices.
  • Etherscan View Blobs is bookmarked on the NOC dashboards, and we're tracking labels for our counterparties. (etherscan.io)
• Data retention
  • We're planning to keep an off-protocol blob archive, keyed by versioned hash, with KZG verification when it's time to restore.
  • Let’s make sure to document that we have about an 18-day on-chain retention SLA for our compliance teams. (eips.ethereum.org)
• Client/wallet updates
  • Estimators and wallets are being tested against EIP-7623’s calldata floor rules, so we can avoid any underpricing issues. (eips.ethereum.org)
• Capacity planning
  • We’ll run through the “parameter bump day” playbook (like target/max increases) to make sure we can adjust the batcher, analytics, and alerts within an hour of activation. (eips.ethereum.org)

---

Frequently asked operator questions

• Can the EVM read blobs?
  • Nope! The EVM can't read blobs during execution. Instead, they get verified through commitments and proofs. If your app requires data that can be read on-chain, stick with calldata or storage. (info.etherscan.com)
• How many blobs should I pack per transaction?
  • You can go for up to 6 pre‑Pectra and usually aim for around 9 post‑Pectra, depending on what your client or tooling is like. Most batchers find that targeting 5-6 blobs works best for efficiency. Just make sure to check the latest network parameters to be on the safe side. (eips.ethereum.org)
• Where can I find the “real” blob price?
  • You can check out Etherscan’s “View Blobs” page for the latest inclusions, which include Excess Blob Gas and effective fees. If you're into programmatic work, just take a look at the blob fields in the block headers and calculate the base fee according to EIP‑4844. (etherscan.io)
• What goes down after 18 days?
  • Consensus clients kick in and prune blob payloads; if you need that data, make sure you (or someone else) holds onto it. But don’t worry, integrity remains provable thanks to the commitment saved on L1. (eips.ethereum.org)

---

The strategic takeaway

• After Post‑Pectra, we saw blob capacity go up to double (aiming for 6, maxing out at 9), and the cost of calldata for data availability really took a hike while fee pressure lightened up. Come December 2025, PeerDAS is kicking off a transition to sampling that opens the door for even more capacity boosts through smaller, focused BPO forks. Now, take that and weave it into your own game plan: think blob‑first, pack those batches tightly, keep an eye on excess_blob_gas with some automated monitoring, and whip up an archiving strategy that’s linked to a versioned hash. If you start treating Etherscan’s blobs pages as a live DA market console--and build your design around parameters that can shift frequently--you’ll be turning Ethereum’s ever-changing data layer into a reliable cost line rather than an ongoing surprise. (eips.ethereum.org)

---

References and further reading

• Check out the EIP‑4844 (proto‑danksharding) spec! It covers transaction types, blob structures, gas calculations, and some cool pruning parameters. You can dive into all the details here.
• If you're curious about blobs on Ethereum, the Etherscan Information Center has got you covered! There’s an overview and handy links to View Blobs and a blob gas tracker. Take a look here.
• Want to see blobs in action? Here’s the Etherscan View Blobs page--it's live on the mainnet! Check it out here.
• Pectra has put together some insights on EIP‑7691, which focuses on increasing blob throughput, along with a post-upgrade analysis about capacity and costs. You can find the details here.
• Don’t miss the scoop on EIP‑7623, which tackles calldata floor pricing, plus some migration notes for estimators and wallets. Get the full rundown here.
• Curious about the EIP‑7594 (PeerDAS) and its activation timeline? You can read more about it here.
• Here’s an interesting one: EIP‑7892 focuses on hard forks that deal only with blob parameters. Explore it here.
• Lastly, Blocknative has a great primer on blobs--why packing matters and how you pay for a complete blob. Don’t miss it here.

If you're looking for a handy worksheet to input your own batch sizes, cadence, and fee ceilings, just let us know! We're happy to share our 7Block Labs blob pricing calculator template with you.