Three units, stacked
Nimiq's chain is built out of three nested units, and once you can tell them apart you can read almost anything else on the network. They nest the way seconds, minutes and hours do:
| Unit | What it is | How long | Closed by |
|---|---|---|---|
| Micro block | The ordinary block that carries user transactions, produced by the validator holding the current slot | About one second, measured average about 0.987 seconds | Nothing. The next micro block follows it |
| Batch | A run of 60 blocks, 59 micro and one macro | About one minute | A macro block, which is where finality happens |
| Epoch | A run of 720 batches, so 43,200 blocks | About 12 hours | An election block, which picks the next validator set |
The rest of this page takes each row and shows you how to see it on a live chain. The constants come from the node software's own mainnet policy, and the worked reading at the end is a real one from our own node on 14 September 2026. How Albatross works is the companion page that explains the mechanism underneath these numbers; this one is about the skill of reading them off the chain.
Micro blocks: one producer, about a second
A micro block is the ordinary unit of the chain. It carries user transactions, and it is produced and signed by a single validator, the one that owns the current slot. There is no competition to produce it: the protocol has already decided whose turn it is, using a verifiable random function that reshuffles the slot owner list for every single micro block.
The one thing a reader of the chain needs to know about micro block timing is that one second is a target, not an enforced minimum. The constant in the node software is literally commented as the optimal time between blocks, and producers publish when they are ready. Measured across the life of the proof of stake chain, the average gap between blocks is about 0.987 seconds, roughly 1.3% quicker than the target.
That has a practical consequence if you ever try to convert a block height into a date: do not multiply by exactly one second. The chain runs about nine days ahead of where a strict one second metronome would have it.
When the expected micro block does not arrive, the remaining validators produce a skip block in its place. A skip block carries no transactions, inherits the previous random seed, timestamps itself four seconds after the previous block, and needs a supermajority of signatures. It is how the chain moves on without waiting for a validator that went offline.
The batch: 60 blocks, closed by a macro block
Every sixtieth block is not a micro block. It is a macro block, and a run of 59 micro blocks closed by one macro block is a batch. Sixty blocks in total, which at about one block a second puts a batch at about a minute.
Two ways the numbers are phrased, and both are right:
-
The node software declares
blocks_per_batch: 60, and fires the macro block on the last index of the batch. That is counting all 60 blocks. - The documentation often says a batch has 59 micro blocks. That is counting only the micro ones, and leaving the closing macro block implied.
Same batch, two counting conventions. 59 micro plus 1 macro equals 60 blocks.
The macro block is a different kind of object from the micro blocks it closes. It carries no user transactions, only the reward distribution for the batch. And it is not produced by a single validator: it is proposed, then voted through in a Tendermint process that needs the agreement of more than two thirds of the 512 validator slots.
That vote is where finality happens. Once the macro block closing a batch is confirmed, every transaction in that batch is settled. Not probably settled, settled. The protocol has no mechanism to reverse it. So the honest answer to "when is my Nimiq payment final" is: when the current batch closes, at most about a minute after it is included and on average about thirty seconds.
The epoch: 720 batches, closed by an election block
A run of batches makes an epoch, and an epoch is
720 batches, so 43,200 blocks, so about 12 hours. These are the mainnet
policy constants in the node software: batches_per_epoch: 720 and
blocks_per_batch: 60.
Worth stating the correction the node software settles, because a number you will meet elsewhere is wrong. Some documentation says an epoch is 1440 batches, in the same breath as calling it 12 hours, and both cannot be true at roughly one batch per minute. At 1440 batches, an epoch would be 24 hours. The chain's own numbers only divide at 720, so this site publishes 720 and not the other figure.
The defining property of an epoch is that the validator set does not change inside it. Whoever was elected at the start validates until the end, and there is no mid epoch replacement even for a validator that goes offline or gets jailed. That is what makes the epoch the unit of election, and it is why the boundary matters.
The election block
The last macro block of an epoch is an election block. It does everything an ordinary macro block does, and on top of that it chooses who validates next. It hands out 512 slots among validators in proportion to total stake, using the randomness from the election block's own seed, and the result is fixed for the whole of the following epoch.
Two consequences are worth holding onto, because both surprise people.
- Election is re-run from scratch every 12 hours. Being elected in one epoch guarantees nothing about the next. A validator holding a small fraction of total stake may well receive no slots at all in a given epoch, and that is the design rather than a fault. Choosing a Nimiq validator teaches readers to read that state, and our validators page shows who is on which side of it right now.
- A staker never holds a slot. Your delegation adds to the weight that earns your validator its slots. It does not give you one. That is the root of why rewards reach you through the validator rather than from the protocol directly.
Because the set does not change inside an epoch, stake changes only take effect at the next election block. A fresh delegation starts counting somewhere in the next half day, and a deactivation opens a reporting window that runs to the end of the following epoch. The timing rules are walked in how to unstake NIM.
Reading all three in an explorer
None of this requires trusting us, and the fastest way to learn it is to watch it happen. Open the block explorer and watch blocks arrive about a second apart. Then watch the height cross a multiple of 60 and you will see the macro block that closes the batch. Keep going and you will cross an epoch boundary, where the producing validator set changes.
Three things to look for, one per unit:
- Micro blocks: the block height increments roughly every second, and every ordinary block carries transactions.
- A macro block: it lands at every height that is a multiple of 60, counted from the proof of stake genesis of 3,456,000. It has no user transactions, only the batch reward.
- An election block: the macro block that closes the last batch of an epoch, at the 720th batch. After it, the set of validators producing blocks changes.
The validators page shows the real set with each one's stake and elected status, which is the practical way to see an election happen rather than reading every macro block.
A worked reading, 14 September 2026
Here is a real reading from our own node, taken on 14 September 2026, at block 61,538,832, in epoch 1345:
| Field | Reading |
|---|---|
| Block height | 61,538,832 |
| Epoch | 1,345 |
| Batch | 968,014 |
| Batch within the epoch | 334 of 720, with 386 remaining |
The arithmetic is the same as on the protocol reference page, and it closes exactly. The proof of stake chain began at block 3,456,000. If a batch is 60 blocks, then 968,013 batches have closed and the chain is 35 blocks into the next one:
3,456,000 + (968,013 x 60) + 35 = 61,538,832
Which is the height the node reported. And if an epoch is 720 batches:
(1,344 x 720) + 334 = 968,014
Which is the batch the node reported, and the 334 matches the batch-within-epoch figure the endpoint returns independently. Both equations close on the nose, which means the constants are right and no interval is missing anywhere between the migration and now. Reading a chain is, mostly, this: check that the numbers agree, and the numbers will tell you where you are.
Why an operator cares about each of these
For a reader who is just following a transaction, the units are mostly about timing. For anybody running a validator or deciding where to stake, they are the difference between working and not working.
- Micro blocks are the work. A validator produces the micro blocks for the slots it holds, and missing one burns the reward for that slot.
- The batch is the payment. The batch reward is paid to the validator's reward address every batch, one batch in arrears, and that is where a validator's income shows up on chain.
- The epoch is the election. Whether your validator produces anything at all is decided fresh at every election block, so a validator that is not elected in a given epoch produces nothing and has nothing to distribute at any fee.
That last point is the one that trips up most newcomers: a validator can be registered, active and unelected all at once, and it is the election block that separates "on the network" from "producing blocks". The states are set out in how Albatross works, and the practical consequence for choosing where to stake is in choosing a Nimiq validator.
All live figures on this page are a single reading taken at block 61,538,832 on 14 September 2026 and will have moved since. We publish no price figures anywhere on this site and nothing on this page is financial advice.