Understanding Cardano Transaction Fees

Transaction fees on Cardano are designed to be predictable, deterministic, and calculable in advance. Unlike Ethereum’s gas auctions, where users compete for block space, and prices swing with demand, Cardano’s fee model is a fixed formula tied to on-chain protocol parameters. You can work out exactly what a transaction will cost before you submit it.

The deterministic fee model

Cardano calculates the minimum fee for a basic (non-script) transaction using a linear formula:

fee = a × size(tx) + b

Where:

• a is the per-byte coefficient (minFeeA / txFeePerByte in protocol parameters)
• size(tx) is the size of the serialised transaction in bytes
• b is the fixed base fee (minFeeB / txFeeFixed in protocol parameters)

Current mainnet values:

• a = 44 lovelace per byte
• b = 155,381 lovelace (about 0.155 ADA)

A typical ADA send is around 260 bytes, so the base fee works out to:

155,381 + (260 × 44) = 166,821 lovelace ≈ 0.167 ADA

That’s the number your wallet shows when you hit send. No estimation, no priority tier, no last-minute spike.

Factors that affect the fee

Three things drive the cost of a Cardano transaction.

1. Transaction size

More inputs, more outputs, more metadata, more native tokens, more witnesses, all add bytes. Every byte costs another a lovelace.

2. Plutus script execution

Transactions that run smart contracts pay an additional fee on top of the linear base fee:

script_fee = priceMemory × memory_units + priceSteps × cpu_steps

executionUnitPrices is a separate protocol parameter. As of 2026, priceMemory sits around 0.0577 and priceSteps around 0.0000721 lovelace per unit. A simple validator might consume a few million memory units and tens of millions of CPU steps. A complex DEX swap or aggregator route can consume orders of magnitude more, which is why DApp transactions usually cost noticeably more than plain sends.

3. Reference scripts (Conway era)

Since the Chang and Plomin hard forks, transactions that use reference scripts pay an additional fee based on the size of the referenced script. The pricing is tiered to discourage oversized reference scripts:

• 0 to 25 KB: 1.0× base rate
• 25 to 50 KB: 1.2× base rate
• 50 to 75 KB: 1.44× base rate
• And so on, scaling up multiplicatively

The base rate is set by the minFeeRefScriptCostPerByte parameter. This matters in practice for any DApp that uses reference scripts heavily, which is most of them in the Conway era.

What Cardano fees are not

Cardano does not have a fee market. Higher fees do not buy you priority. The cardano-node mempool is FIFO: transactions are processed in the order they arrive, regardless of fee paid. The ledger specification technically allows for a fee market, but the current node implementation ignores it. Paying more than the minimum gets your transaction confirmed at the same speed as paying the minimum.

This is by design. Cardano’s deterministic model is the whole point: you should always know exactly what a transaction costs before submitting, with no surprises driven by network congestion or rival bidders.

Where fees actually go

Fees in Cardano do not flow directly to the block producer. They are pooled into the rewards pot at the end of each epoch, combined with monetary expansion drawn from the reserves. That pot is then distributed to stake pools that actually produced blocks during the epoch. From there, rewards flow to each pool’s operator (their fixed cost and margin) and to the pool’s delegators (proportional to delegated stake).

So it’s correct to say fees end up with stake pool operators and delegators, but the mechanism is indirect, epoch-based, and tied to block production rather than transaction-level tipping.

Minimum UTxO ADA

Related to fees but technically a separate concept: every UTxO on Cardano must hold a minimum amount of ADA, governed by the coinsPerUTxOByte parameter. A plain ADA-only output costs around 1 ADA minimum. Outputs carrying native tokens, inline datums, or reference scripts cost more because the UTxO is larger.

This trips up new builders regularly. If you try to create an output below the minimum, the transaction fails on validation before the fee even applies.

Calculating fees with cardano-cli

Modern cardano-cli (Conway era and later) calculates the minimum base fee with:

cardano-cli transaction calculate-min-fee \
  --tx-body-file tx.draft \
  --protocol-params-file pparams.json \
  --witness-count 1

The older --tx-in-count and --tx-out-count flags have been deprecated. The CLI now derives those counts from the transaction body file directly.

A few practical notes:

• This calculates the minimum fee only. It does not validate the wider transaction (balancing, witnesses, script correctness).
• For transactions that include Plutus scripts, prefer cardano-cli transaction build over build-raw, because build auto-estimates script execution units and adjusts the fee accordingly.
• For reference scripts, recent cardano-cli versions accept a --reference-script-size flag if you need to compute fees for a draft that references on-chain scripts.

A practical example

Suppose Alice wants to send 100 ADA to Bob.

1. Draft the transaction with one input (Alice’s UTxO holding 200 ADA), two outputs (100 ADA to Bob, change back to Alice), and an estimated fee.
2. Calculate the minimum fee. Suppose the serialised transaction is 250 bytes and uses one witness. Fee = 155,381 + (250 × 44) = 166,381 lovelace, or roughly 0.166 ADA.
3. Balance the transaction so inputs equal outputs plus fee. Alice’s change becomes 200 – 100 – 0.166381 = 99.833619 ADA.
4. Sign with Alice’s payment key and submit to the network.

The number Alice’s wallet quoted at the start is the same number that settles on chain at the end.

Why the deterministic model matters

The deterministic fee model is one of Cardano’s strongest UX properties. Users always know what they’re paying. DApp builders can quote exact transaction costs upfront. Wallets show accurate fee estimates without polling external oracles or guessing at congestion. And critically, failed Plutus transactions don’t drain a user’s wallet, because scripts terminate predictably with success or failure (with the well-defined exception of collateral consumption on script failure).

If you’re building on Cardano, the practical takeaway is straightforward. Read the current protocol parameters, plug them into the formula, account for script execution and reference script costs where they apply, and you have your number. No gas wars, no priority auctions, no surprises.

Sources

• Cardano Developer Portal, Transaction Fees: developers.cardano.org/docs/learn/core-concepts/fees
• Cardano Docs, Fee structure: docs.cardano.org/about-cardano/explore-more/fee-structure
• Cardano Docs, Transaction costs and determinism: docs.cardano.org/about-cardano/learn/transaction-costs-determinism
• cardano-cli reference: github.com/IntersectMBO/cardano-cli