How transaction fees are calculated, why they are predictable, what the minimum ada requirement means, and how Cardano's accounting model compares to account-based blockchains.
Every transaction on Cardano pays a small fee. The fee is not set by block producers in an open auction, and it does not depend on how much ada you move. Instead, it is calculated from the size of the transaction in bytes using public, network-wide protocol parameters.
Because the size of a transaction is known before you submit it, the exact fee is knowable in advance. That predictability is one of Cardano's defining user-experience properties: you see the price before you sign.
The minimum transaction fee is fee = a × size + b, where size is the transaction's serialized size in bytes.
On mainnet, a (the per-byte component, protocol parameter minFeeA / txFeePerByte) is 44 lovelace per byte, and b (the fixed component, protocol parameter minFeeB / txFeeFixed) is 155,381 lovelace. A simple ada transfer is typically 200–300 bytes, so the fee works out to a fraction of an ada, roughly 0.16–0.17 ada.
Both a and b are protocol parameters. They are not hardcoded constants, and they can be changed through the network's governance and parameter-update process.
Cardano's fee depends only on transaction size and two public parameters. The size is fixed at construction time, so the wallet can compute the exact fee and show it to you before you authorize the transaction.
This contrasts with account-based models such as Ethereum, where fees are driven by computation (gas) inside the virtual machine (the on-chain execution environment) rather than by transaction size. There, the exact cost can depend on contract execution paths, so it is less directly tied to the bytes you publish.
Why it matters: predictable fees mean no surprise overpayment, no bidding war to get included in a block, and a calmer user experience, especially for everyday payments.
Cardano uses the UTXO model (extended, or eUTXO), where value lives in discrete outputs rather than in accounts with running balances. To stop the ledger from filling up with tiny dust outputs, every output must contain a minimum amount of ada.
Since the Babbage era, that minimum is calculated as (160 + serialized output size in bytes) × utxoCostPerByte, where utxoCostPerByte (the coinsPerUTxOByte parameter) is 4,310 lovelace per byte on mainnet. The fixed 160-byte overhead covers the transaction input and the output's entry in the UTxO set.
A simple ada-only output therefore carries roughly 1 ada as its minimum. Outputs that hold native tokens, a Plutus script (Cardano's smart contract language), or an inline datum (data attached directly to the output) are larger, so their minimum ada is higher. The ada is locked, not burned: it is returned in full when the output is later spent.
A basic ada-only output serializes to about 67 bytes. At 4,310 lovelace per byte the locked minimum is (160 + 67) × 4,310 = 978,370 lovelace, or about 1 ada.
Add a native token or an inline datum (data attached directly to the output) and the serialized size grows, so the required minimum ada grows in step. This is the UTxO cost per byte rule in action.
In an account-based model, the chain tracks each address's balance and a transaction mutates it. Fees there are driven mainly by computation: the more work a transaction does inside the virtual machine (the on-chain execution environment), the more it costs.
In Cardano's extended UTxO model, a transaction consumes whole inputs and creates new outputs. Fees are driven by the size of what you publish to the chain. Scripts still have their own execution budget and cost (priced through separate protocol parameters), but the base fee reflects footprint, not the script's execution cost.
Size, not steps: a large but simple transaction can cost more than a small transaction that runs a script, because the fee formula weights the bytes you add to the ledger.
Unlike account-based chains with open gas bidding, Cardano has no general fee market where users outbid each other to be included. The per-byte fee plus the configurable minimum is the price; there is no auction for block space in the usual sense.
Some maximal extractable value (MEV) still exists. The protocol does not enforce any transaction order within a block, and the stock node simply fills blocks in mempool arrival order. Reordering transactions would require a modified block producer, while back-running (adding your own transaction after one you see in the mempool) needs no modification at all. What actually keeps MEV limited on Cardano is that a transaction's inputs and outputs are fixed when it is built: a reordered transaction cannot be made to execute at a worse price, it either goes through as written or fails.
For a typical ada transfer, expect to pay a tiny, predictable fee, a fraction of an ada (around 0.16–0.17 ada at current mainnet parameters), plus the refundable minimum-ada deposit on any new output. Your wallet shows the exact fee before you sign.
Explore the UTXO model