Does this page show the Cardano mempool queue?

No. Nothing in this deployment samples a node's /mempool endpoint, so the backlog of unconfirmed transactions is not measured here rather than estimated. What the page reports is the block bodies that made it on chain: their size saturation, the transactions they carried and the fees those transactions paid.

How full are Cardano blocks?

The distribution answers that, not the average. The page sorts the blocks of a sampled hour into four bands of the live block body limit - under 2, 2 to 5, 5 to 10 and over 10 percent - and prints the share of each band, the median block and the fullest block of that window. How full the chain runs is not constant, so the bands are read against each other rather than against a single number.

Are Cardano transaction fees set by bidding?

No. A transaction pays a deterministic base fee of a times its size plus b, and for Plutus execution additionally price_mem times memory units plus price_step times CPU steps. The Fee Model table on this page lists the values the network is currently running.

Why can the transaction-mix shares add up to more than 100%?

Because one transaction can at the same time execute a Plutus script, move native assets and register a governance action. Each share is measured independently, so the four shares overlap; they are 24-hour, transaction-weighted means.

How do Plutus script execution units affect block fullness and transaction fees?

Plutus smart contracts consume execution memory units and CPU steps alongside raw byte size. Each block has independent ceilings for total body size, total execution memory, and CPU steps, ensuring computationally heavy scripts cannot congest byte throughput or exhaust validator memory.

Block space & capacity cockpit · confirmed ledger census

Cardano Block Space & Transaction Mix Telemetry

This page measures the block space Cardano actually uses: how full each block is, how many transactions it carries, what those transactions contain (simple ada, native assets, Plutus scripts, governance) and what they pay in fees. Mempool depth is not shown here — following the unconfirmed-transaction backlog would need a constant /mempool sampling of a node, which this deployment deliberately does not pay for. The queue is therefore unmeasured rather than estimated.

Mean body saturation · 24 h summary

vs live block body limit

                  
                  Tx per Block Ø (1h)
                
                  --
                  txs
                
--

Mean Throughput (24h)

-- TPS

Network Velocity (24h)

Mean Tx Fee (24h)

-- ADA

All fees paid, 24h mean

Plutus Script Share

Smart Contract Execution

How Full Are the Blocks?

Every block of the sampled hour, by its body size against the live body limit. The bar is the share of blocks in that band, the number beside it the block count. These are the bands the feed filters by — click one to narrow the table below.

Under 2% of the body limit --

2 – 5% of the body limit --

5 – 10% of the body limit --

Over 10% of the body limit --

Median block (1 h) --

Fullest block (1 h) --

Sampled (1 h) --

How Big Are the Transactions?

A sample of the transactions the sampled hour's blocks carried, bucketed by serialized size. Cardano's fee grows linearly with size, so this shape is what the fee distribution follows — a few transactions per block, not a census of the hour.

Under 250 B

250 – 500 B

500 B – 1 kB

1 – 4 kB

Over 4 kB

Median size --

95th percentile --

Live max tx cap --

eUTXO Transaction Mix

One transaction can execute a Plutus script, move native assets and register a governance action at the same time, so the five shares are measured independently and overlap (they can sum past 100%). Each bar is that class's own share of all transactions, which is why the five do not have to add up.

Simple ADA transfers

Plutus smart contracts

Native assets & mints

Governance & staking

Mint & Burn (NFTs)

Distinct assets / block --

Token transfers / block --

Mint or burn share --

Execution Budgets

Body bytes are one of three ceilings a block has to fit under. A block can carry a few kilobytes and still spend most of its CPU-step budget, so both execution ceilings are measured here on the same hour.

CPU steps --

Memory units --

Fee model & protocol ceilings →

Block Fill Timeline (1h)

One bar per block of the sampled hour, coloured by the band it lands in. The dashed line is the hour's mean; the fullest block is called out with its time.

Block Space, Last 5 Days

The mean body fullness of every counted hour in the stored rollup window — the same measurement as the hour above, across days. An hour without a stored sample stays blank: a gap is a missing hour, not a block that was measured empty.

Live Block Space Feed (Recent Blocks)

Real-time Block Telemetry

Real-time log of recently observed blocks: transactions carried, body size, Plutus script memory units and fee yield. A block height opens that block in the Block Pile; any SPO opens its telemetry.

Block / Slot	Slot Leader (SPO)	Txs	Block Size	Script Memory / Tx	Block Fees	Block Load
Connecting to Cardano block space telemetry...

Fee Model & Limits

Live Protocol Parameters

Fees on Cardano are arithmetic rather than a market: a · size + b for every transaction, plus price_mem · mem + price_step · steps for Plutus execution. The values below are the ones this network is running right now, and the worked example is computed from them rather than typed in.

Parameter	Value	Source
Fee per byte a	--	live protocol parameters live
Fee constant b	--	live protocol parameters live
Script memory price	--	lovelace per memory unit live
Script step price	--	lovelace per CPU step live
Maximum transaction size	--	live protocol parameters live
Maximum block body size	--	live protocol parameters live
Execution units per transaction	--	memory / CPU steps live
Execution units per block	--	memory / CPU steps live
Execution steps used per block	--	mean of the last hour, steps per tx × txs measured
Execution memory used per block	--	mean of the last hour, memory per tx × txs measured
Collateral requirement	--	of the fee, maximum inputs live
Reference script cost	--	lovelace per byte live
Coins per UTXO byte	--	minimum UTXO sizing live
Base fee for a 300-byte transaction	--	a × 300 + b computed
Measured mean fee per transaction	--	live 24 h summary measured

Cardano eUTXO & Block Space Architecture

Cardano uses the extended UTXO (eUTXO) deterministic accounting model. Transactions specify exact input UTXOs and output UTXOs along with fee parameters:

Deterministic Fees: Transaction fees on Cardano are calculated deterministically from byte size (a · size + b) plus exact Plutus script execution units (price_mem · mem + price_step · steps).
No Priority Bidding Warfare: Unlike account-based blockchains, Cardano transactions do not suffer from unpredictable gas bidding spikes during high traffic.
Block Space vs. Mempool Queue: Nodes enforce a maximum mempool byte limit (default 2 × maxBlockBodySize = 176 KiB) and drop transactions above it, but the pending queue lives only inside the relay nodes — it is not part of the ledger. What is observable on-chain, and what this page reports, is the block body: its size saturation, the transactions it carried and their fees. Sampling the queue itself would require continuously polling a node's /mempool endpoint, which this deployment does not do.