At 08:41 UTC on 23 October 2026, a blockchain e riceve una ricompensa, rendendo carissimo riscrivere lo storico.">mining pool called AntPool added Bitcoin block 972,742 to the network. It holds 6,179 transactions and weighs 1.6 megabytes. It also carries a 64-character code: the fingerprint of block 972,741, which carries the fingerprint of block 972,740, and so on back to 3 January 2009. Until 08:41, none of those 6,179 payments was in a block. Now they sit inside a chain that thousands of computers keep and check for themselves.
That is how a blockchain works, in one sentence: it is a list of blocks of transactions in which each block contains the fingerprint (the hash) of the one before it, copied on many computers, called nodes, that follow the same rules to agree on one valid chain and on who owns what at this moment.
This lesson follows a payment through that machinery, from the moment it is sent to the moment it changes a balance. By the end you should be able to read a block explorer, see why a transfer is “pending” and then “confirmed”, and tell the history stored in the chain from the current state that nodes compute from it. Every figure below was taken from public explorers and official documentation on 23 October 2026.
If the word is new to you, start with our beginner lesson on what a blockchain is, which compares a shared ledger with a bank’s database, and the three pillars of blockchain. The wallet side of a transfer (address, fee, confirmation screen) is covered in how crypto transactions work. Here we stay on the part users do not see: what happens between “sent” and “done”.
How a blockchain works, in five moves
Every public blockchain has its own vocabulary, but Bitcoin and Ethereum, the two largest, follow the same sequence. A transaction meets five things in this order.
- It is announced to the network and waits, with thousands of others, in a waiting area that each node keeps in memory.
- Someone (a miner on Bitcoin, a validator on Ethereum) picks waiting transactions and packs them into a block.
- The block includes the hash of the previous block, which ties it to everything that came before and makes a chain.
- Every node receives the block, checks it against the rules on its own copy of the data, and passes it on only if it is valid.
- The nodes agree on which chain is the real one when two versions compete, and they update the “state”: the list of who owns what now.
Satoshi Nakamoto described the first two steps in the Bitcoin white paper of 2008 in two short lines: “New transactions are broadcast to all nodes. Each node collects new transactions into a block.” The rest of this lesson takes the five moves one at a time. Our lesson on the Bitcoin white paper covers the rest of that document.
A transaction first waits in a pool that every node keeps
Announce, check, relay
A wallet that sends bitcoin does not send it to a company. It hands a signed message to one or more nodes it is connected to. Each node checks that message before doing anything with it: is the format right, do the coins exist, have they already been spent? Only then does it tell its own peers that it has a new transaction. The Bitcoin developer guide describes the exchange as an announcement followed by a request, and says a peer forwards a transaction only “given that it is a valid transaction”. An invalid payment therefore dies at the first honest node. It never reaches the rest of the network.
Ethereum works the same way. A signed transaction goes to a node, which checks it and gossips it to its peers. The transaction then waits until a block producer includes it.
One node’s view: 46,941 transactions waiting
Transactions that are valid but not yet in a block sit in what Bitcoin Core calls the memory pool, or mempool. The name is literal: the developer guide says Bitcoin Core keeps unconfirmed transactions “in non-persistent memory”, so a node that shuts down loses them, apart from the ones its own wallet sent. A payment that pays too little to be picked up can therefore fade away as nodes restart. That is why a stuck transfer sometimes “disappears” from an explorer: the nodes behind it have dropped it.
There is no single, official mempool. Each node has its own, and two nodes rarely hold exactly the same list. At 08:44 UTC on 23 October 2026, the node behind the explorer mempool.space held 46,941 unconfirmed transactions taking up 24.3 million virtual bytes, about six blocks’ worth of space. Another node, at the same second, would show a slightly different number.
A block is a batch: who builds it and how big it can be
On Bitcoin, a miner packs the block
On Bitcoin the block is built by a miner. The miner chooses waiting transactions, places them in a block, and then has to find a valid proof of work for it, a search that takes the whole network about ten minutes on average. The winner collects a reward made of newly created coins plus the fees of every transaction in the block. For block 972,742, mempool.space shows 3.125 BTC of new coins, the amount set by the halving of 20 April 2024, plus 0.00861901 BTC of fees. Since the fees go to whoever mines the block, miners have a reason to prefer the transactions that pay more for the space they use.
Space is limited. Since the SegWit upgrade, the rule written in BIP 141 is that a block’s “weight” may not exceed 4,000,000 units, a measure that counts signature data more lightly than the rest. In practice this gives blocks of about 1.6 megabytes, as the table below shows. Block 972,742 used 3,994,021 units, almost the full allowance.
Ten minutes is an average, not a timetable. In the table below, the gap between two consecutive blocks ranges from 33 seconds to just over 16 minutes. The network keeps the average close to ten minutes by adjusting the difficulty every 2,016 blocks: the developer guide explains that the target time for those 2,016 blocks is two weeks, and difficulty rises or falls so the next batch takes about that long. On 23 October 2026, mempool.space put the average block time of the current period at 9.56 minutes, with the next adjustment due at block 973,728.
| Block | Found (UTC, 23 Oct 2026) | Transactions | Size (bytes) |
|---|---|---|---|
| 972,742 | 08:41:36 | 6,179 | 1,602,946 |
| 972,741 | 08:37:13 | 3,427 | 1,683,123 |
| 972,740 | 08:20:57 | 4,154 | 1,667,889 |
| 972,739 | 08:06:59 | 6,977 | 1,654,080 |
| 972,738 | 08:04:07 | 7,739 | 1,649,190 |
| 972,737 | 08:03:34 | 5,370 | 1,589,805 |
| 972,736 | 07:54:35 | 6,896 | 1,607,735 |
Source: mempool.space, queried on 23 October 2026 between 08:41 and 08:49 UTC. The number of transactions varies with their size: a block of many small payments holds more of them than a block of a few large ones.
On Ethereum, a validator is drawn for each 12-second slot
Ethereum stopped using mining at the Merge on 15 September 2022 and has run on proof of stake since. Time is cut into fixed slots. In the words of ethereum.org, time “is divided into slots (12 seconds) and epochs (32 slots)”, and one validator is randomly selected to propose a block in every slot. That validator takes transactions from its pool, executes them, and sends the block to the others, who re-run it and vote on it. A slot can stay empty if the chosen validator is offline.
Ethereum measures block size in gas, the unit of computing work behind gas fees. According to the ethereum.org page on blocks, each block has a target of 30 million gas and a hard limit of 60 million, and validators can move the limit by a factor of 1/1024 per block. Block 26,254,213, produced at 08:44:59 UTC on 23 October 2026, held 349 transactions and used 48.8 million gas of its 60 million limit, according to Etherscan.
Each block carries the fingerprint of the one before
A hash function turns any piece of data into a code of fixed length. Bitcoin uses one called SHA-256, which always returns 64 hexadecimal characters. Two properties matter for a beginner. The same input always gives the same code. And the smallest change in the input gives a completely different code, with no visible relation to the first one.
You can try it on any computer. We ran SHA-256 on the sentence “Alice pays Bob 1 BTC” and got a code beginning 123684d93fa4 and ending ce4f88bd. Changing a single character, “Alice pays Bob 2 BTC”, gives a code beginning d9537fd1b3df and ending c5c8ef69. Nothing in the second code hints that only one digit moved. How the function does this belongs to a later lesson on cryptography; here we only need the effect.
Now apply that to blocks. Every Bitcoin block starts with a short header, and the header includes the hash of the previous block’s header. Block 972,742 names its parent as the block whose hash begins with 21 zeros followed by c31167384b43, which is block 972,741. The header also holds a single fingerprint summarising every transaction in the block, so the hash of the header depends on the transactions too. The next lesson opens one block and goes through its header field by field.
The white paper puts the idea in one line: “Each timestamp includes the previous timestamp in its hash, forming a chain”. The word “blockchain” does not appear in the paper; the image of a chain does. Each new block also makes the older ones harder to change.
Why changing one old block breaks every block after it
Suppose someone edits a payment in block 900,000 to send the coins elsewhere. The fingerprint of the transactions changes, so the header of block 900,000 changes, so its hash changes. Block 900,001 still points to the old hash, so it no longer fits. Fixing it changes its own hash, which breaks block 900,002, and so on up to the tip. The Bitcoin developer guide makes the same point: modifying a transaction means modifying its block and every block after it.
On Bitcoin, redoing a block means redoing its proof of work, and the attacker would also have to catch up with the honest network, which keeps adding new blocks. That is why careful sources avoid the word “immutable”. The US National Institute of Standards and Technology, in its 2018 overview NIST IR 8202, calls blockchains “tamper evident and tamper resistant digital ledgers”. Evident, because any edit shows up at once. Resistant, because rewriting it costs more than anyone has so far been willing to spend on Bitcoin. What it would take is the subject of a later lesson on whether a blockchain can be hacked.
Ethereum chains its blocks the same way. Each block references the hash of its parent: block 26,254,213 points to a parent whose hash begins 0x59fdf14e71ec. It also commits to a “state root”, a single fingerprint of the whole state after the block, which we come back to below.
Thousands of computers keep their own copy, but not all keep everything
There is no main server behind Bitcoin or Ethereum. The chain exists as copies on independent computers run by individuals, companies, exchanges, miners and validators, anywhere in the world. Each node downloads blocks from its peers, checks every rule itself and refuses what breaks them. A node does not trust its neighbours; it re-checks them. That is what “decentralised” means in practice, and it is why public and private blockchains differ so much: on a public one anybody may run a node, on a private one the operator decides who does.
Not every node keeps the same amount of data, and the common claim that “every node stores the whole blockchain” is wrong. On Bitcoin, the complete history took up about 777.5 GB of block data on 22 October 2026, according to Blockchain.com’s chart of the chain size (that figure leaves out database indexes). A full node keeps all of it. A pruned node checks every block in the same way but then deletes old ones; bitcoin.org says pruning can bring disk use down to around 7 GB. A light wallet on a phone keeps far less again and relies on full nodes for most of the checking.
Ethereum needs two programs side by side: an execution client, which runs the transactions, and a consensus client, which follows proof of stake. The ethereum.org page on nodes and clients lists several of each (Geth, Nethermind, Besu, Erigon and Il liquid staking consiste nel depositare una moneta proof of stake presso un protocollo che la mette in staking e rilascia un token trasferibile (come stETH di Lido o rETH) che rappresenta deposito e ricompense: lo si può usare o vendere mentre le monete restano in staking.">Reth among the first; Lighthouse, Prysm, Teku, Nimbus and Lodestar among the second). It says a full node checks every block but keeps only recent data, “typically the most recent 128 blocks”, while an archive node keeps every past state. Disk needs are higher than Bitcoin’s: Geth’s documentation (page last edited in September 2023) says Geth alone needs more than 650 GB for a snap-synced full node, and its advice of a 2 TB SSD for Geth plus a consensus client dates from September 2022. Those figures have grown since.
How many nodes are there? Nobody can count them exactly, because many nodes do not accept incoming connections and stay invisible to crawlers. Bitnodes, the best-known Bitcoin counter, showed no figures on 23 October 2026 while it moved to a new operator, and we found no Ethereum count we could verify. “Thousands” for each network, and probably tens of thousands for Bitcoin once hidden nodes are counted, is as precise as an honest source can be today. A related point is client diversity: if most Ethereum nodes ran the same software, one bug in it could affect a large part of the network at once, which is why developers watch the share of each client.
History and state are two different things
The chain is the history: every block, in order. But your wallet does not replay sixteen years of blocks to show your balance. Nodes keep a second structure, the state, which answers the question “who owns what right now”. Each new block is applied to the state, which changes it a little. The history only grows; the state is rewritten block by block.
Bitcoin: unspent outputs, like banknotes in a drawer
Bitcoin has no accounts and no balances in its rules. A transaction consumes earlier outputs and creates new ones. The developer guide says each output “can only be used as an input once in the block chain”, and calls the ones not yet used unspent transaction outputs, or UTXOs. Think of banknotes: to pay 30 with a 50 note, you hand over the whole note and get 20 back in change. Bitcoin wallets do exactly that, creating a change output that returns to the sender.
Nodes keep the list of every unspent output ready to check new payments quickly; developers call it the UTXO set. In a snapshot taken at block 892,385 on 14 April 2025, mempool.space’s research team counted 173,190,861 unspent outputs, needing about 11 GB on disk with default settings. That is far smaller than the 777 GB of history, because spent outputs drop out of it.
Ethereum: accounts with a balance and a counter
Ethereum keeps accounts instead. Each account has a balance, a nonce (a counter of the transactions it has sent) and, for a smart contract, code and storage. A payment subtracts from one balance and adds to another. ethereum.org describes the Ethereum Virtual Machine as a computer “whose state everyone on the Ethereum network agrees on”, and every block carries the root of that state, so a node that applied the block wrongly would get a different root and notice.
| Bitcoin (UTXO model) | Ethereum (account model) | |
|---|---|---|
| What the state holds | Unspent outputs, each with an amount and a spending condition | Accounts: balance, nonce, and code and storage for contracts |
| How a payment is checked | The outputs it spends exist and have not been spent | The sender’s balance covers the amount and fee; the nonce is the next one |
| Everyday picture | Banknotes and change | A bank account statement |
| Where you see it | An address lists its unspent outputs | An address shows one balance |
| Size figure | 173.2 million outputs, about 11 GB (14 April 2025) | Recent state only on a full node (128 blocks) |
Neither model is safer by itself. The UTXO model makes it easy to check payments in parallel and to follow coins. The account model makes programs with a memory, such as lending apps, simpler to write. For a wider comparison of the two networks, see Bitcoin vs Ethereum vs blockchain.
Agreeing on one chain when two blocks appear at once
Messages take time to cross the planet. Two miners can find a valid block at the same height a few seconds apart, and for a moment half the network has one and half has the other. That split is called a fork. Without a rule to settle it, the ledger would split for good.
The white paper’s rule is short: “Nodes always consider the longest chain to be the correct one and will keep working on extending it.” Strictly, nodes follow the chain with the most accumulated work, which is nearly always the longest one. The developer guide puts it as “the most difficult chain to recreate”, and says peers “throw away stale blocks belonging to shorter forks”. As soon as one side receives the next block, every node switches to it, and transactions of the stale block that the winning chain does not already contain go back into the mempool to be picked up again. That switch is called a reorganisation.
Ethereum settles the same problem in two layers. To choose the head of the chain, nodes use a rule called LMD-GHOST, which ethereum.org says works “by identifying the fork that has the greatest weight of attestations in its history”. Attestations are the votes validators cast every epoch. On top of that, a mechanism called Casper-FFG makes blocks final: a checkpoint (the first block of an epoch) that wins votes from validators holding at least two-thirds of all staked ETH becomes “justified”, and once the next checkpoint is justified too, the earlier one becomes “finalized”. Each validator must lock 32 ETH, and one that breaks the rules can lose part of it.
Confirmations on Bitcoin, finality on Ethereum
Because a Bitcoin block can in theory be replaced, a payment there is never final in an absolute sense. Each new block on top of it, called a confirmation, makes replacing it more expensive. The protocol itself shows the logic: the developer guide says new coins created for a miner “cannot be spent” for at least 100 blocks, in case the block that created them is replaced.
Ethereum offers a firmer line. Block 26,254,213 went into slot 15,493,423 of the beacon chain at 08:44:59 UTC on 23 October 2026, in epoch 484,169. When we queried a public beacon node at 08:59 UTC, the last finalized checkpoint still sat just before it; at 09:01 UTC finality had moved past it, a little over 16 minutes after inclusion. An epoch lasts 6.4 minutes, and depending on where in its epoch a block lands, finality normally comes two to three epochs later, roughly 13 to 19 minutes. According to ethereum.org, an attacker trying to revert a finalized block would have to accept losing at least one-third of all staked ETH.
One payment followed from click to state, with real figures
Put the pieces together with two examples. The amounts are illustrative; the network figures are the ones recorded on 23 October 2026.
Alice pays Bob in bitcoin
- Alice’s wallet holds one unspent output of 0.05 BTC. To pay Bob 0.03 BTC, it builds a transaction that spends the whole output, sends 0.03 BTC to Bob and returns the rest, minus a fee, to a new change address of Alice’s.
- The wallet hands the signed transaction to a node, which checks it and relays it. Within seconds it is in mempools around the world, one of tens of thousands of waiting transactions.
- A miner includes it in the next block it works on. If the fee is low compared with the others waiting, it may take several blocks.
- The block is found, about ten minutes later on average. Every node checks it, adds it to its copy and updates its UTXO set: Alice’s old output is removed, Bob’s new output and Alice’s change are added.
- Bob’s wallet shows one confirmation. Each block found after that adds one more.
Alice sends ether
On Ethereum, Alice’s wallet builds a transaction from her account with the next nonce in line, say 42 if she has already sent 42. A simple ether transfer always uses 21,000 gas, according to ethereum.org’s transactions page. The fee is the gas used multiplied by the base fee plus a tip per unit of gas; the base-fee part is burned and the tip goes to the validator. Block 26,254,213 had a base fee of about 0.059 gwei per unit of gas, so the base part of a simple transfer came to 21,000 times 0.059, about 1,240 gwei, or roughly 0.0000012 ETH (one gwei is a billionth of an ether), before any tip. The validator of the next slot includes the transaction, every node executes it, Alice’s balance falls and her nonce becomes 43, Bob’s balance rises. Some 13 to 19 minutes later the block is finalized.
| Dated figure, 23 October 2026 | Bitcoin | Ethereum |
|---|---|---|
| Latest block observed | 972,742 at 08:41:36 UTC | 26,254,213 at 08:44:59 UTC |
| Transactions in that block | 6,179 | 349 |
| Size against the limit | Weight 3,994,021 of 4,000,000 | 48.8 million gas of 60 million |
| Block rhythm | Target 10 min; 9.56 min average this period | Fixed 12-second slots |
| Who added it | Mining pool AntPool (proof of work) | Validator drawn for the slot (proof of stake) |
| When a payment is settled | Never absolutely; more confirmations, more cost to undo | Finalized after two to three epochs (about 13 to 19 minutes; 16 minutes for block 26,254,213) |
| Network effort or stake | Difficulty about 140.6 trillion; roughly one zettahash per second | 32 ETH per validator |
| History on disk | About 777.5 GB (22 October 2026) | Over 650 GB for Geth alone; 2 TB SSD advised (Geth docs, 2022-2023) |
Sources: mempool.space, Blockchain.com, Etherscan, a public Ethereum beacon node, ethereum.org and the Geth documentation, consulted on 23 October 2026.
What the mechanics explain about your wallet and your exchange
Once you know how a blockchain works, several everyday puzzles make sense. A transfer marked “pending” is sitting in mempools and has not been picked yet; a higher fee usually gets it in sooner. An exchange that waits for several confirmations before crediting a bitcoin deposit is guarding against a reorganisation; each platform sets its own number, and its help pages give it. A deposit on Ethereum is often credited faster because finality comes within minutes.
Your wallet does not store the blockchain. As our guide to crypto wallets explains, it holds your keys and asks nodes for your share of the state, which is why a new phone can show your balance as soon as you restore your wallet. The coins never were on the old phone; they are entries in a ledger kept by thousands of computers. The very first block of that ledger, mined in January 2009, is still the start of every copy.
You can check all of this yourself. Paste a transaction ID into mempool.space for Bitcoin or Etherscan for Ethereum and you will see the block that holds it, the previous block’s hash and the number of confirmations. No account and no permission are needed: that open access is the point of a public ledger.
What US and UK regulators cover, and what they leave to the code
No regulator decides how a blockchain works at this level, how blocks are chained or how nodes agree; those rules are code, changed only when node operators adopt new software. The SEC, the CFTC, the IRS and, in the UK, the FCA and HMRC deal with what is built on top: whether a token is a security or a commodity, how exchanges must behave, how gains are taxed. The US government’s technical reference on the machinery is the NIST overview quoted above, written to explain the technology, not to regulate it. In practice, a transaction is “on chain” when the network has recorded it, whatever a US or UK authority later decides about the asset it moved.
The next lesson opens a single block and reads its header field by field, from the version number to the nonce.
