Learn · Updated November 18, 2026

How long a Solana transaction stays valid

Solana blockhash expiry limits how long a transaction can land: its recent blockhash must be among the last 150 blockhashes a validator has seen, one per slot that produced a block. Once it falls out of that window the transaction is rejected for good. Durable nonce transactions are the exception, because their blockhash field holds a nonce instead.

The recent blockhash#

Every transaction carries 32 bytes called the recent blockhash, written by the sender just before signing. Solana's documentation gives it two jobs: proving the transaction was made recently, and preventing the same transaction from being processed twice. Validators keep a queue of recent blockhashes and a status cache of messages they have already processed; a transaction must find its blockhash in the queue and must not already be in the cache.

What is inside a Solana transaction shows where the field sits in the bytes.

The validity window#

QuestionAnswerSource
How many blockhashes count as recent?150 (MAX_PROCESSING_AGE)Solana SDK clock constants and the transaction pipeline docs
Counted in what?blockhashes, one per slot that produced a block; skipped slots add noneSDK clock comment: "one blockhash per non-skipped slot"
What happens after that?the transaction is rejected with BlockhashNotFoundtransaction structure docs
How does a client know the deadline?getLatestBlockhash returns a lastValidBlockHeight; the transaction can land while the block height is at or below itRPC docs
Did faster slots change the count?no: SIMD-0525 left the blockhash queue size unchanged, so the window got shorter in wall-clock timeSIMD-0525

The documentation states the window as 150 slots; the code counts blockhashes, and only slots that produced a block add one, so with skipped slots the window is a little longer than 150 slots. At the 200 ms slot target, 150 blocks take roughly 30 seconds or more.

When we asked mainnet RPC at slot 470,922,489, getLatestBlockhash returned a last valid block height of 448,937,235 while the current block height was 448,937,090: 145 blocks of headroom left for a blockhash fetched at that moment. The deadline is a block height, not a slot; slot or block height explains the difference.

Durable nonce exceptions#

A durable nonce transaction starts with a System program AdvanceNonceAccount instruction, and the field that normally holds a recent blockhash holds the stored value of a nonce account instead. The validator checks the nonce rather than the blockhash queue, so the transaction does not expire after 150 blocks; it stays valid until the nonce account is advanced. That is what makes offline signing possible, and it is why expiry tells you nothing about these transactions. Durable nonce transactions shows how to recognise them. They are not rare: two consecutive mainnet blocks we sampled held 24 of them.

Using expiry to retire provisional rows#

  1. When you decode a transaction from shreds, keep its blockhash with the row, and note whether its first instruction advances a nonce.
  2. If reconciliation finds a status at confirmed or finalized, settle the row: confirmed or failed. Expiry no longer matters.
  3. If there is no status yet, ask whether the blockhash is still valid with isBlockhashValid at finalized commitment, once per distinct blockhash. The processed tip may be a fork that does not survive.
  4. Valid: wait. The transaction can still land in any later slot.
  5. Expired: ask for the status once more, since it may have landed in between. Still nothing means dropped, provided your RPC node still holds that slot's history; otherwise missing history looks the same as a missing transaction.
  6. Durable nonce: never retire by expiry; apply your own time limit and keep it provisional until then.

This is the rule reconciling with RPC implements in code.

Why expiry is the clock a shred pipeline needs#

A shred decoder sees transactions before anyone knows their outcome, including ones in blocks that are later skipped. "Skipped" is not a final answer for a transaction: the same transaction can land in a later block as long as its blockhash is valid. Expiry is the first moment you can say a transaction that has not landed never will, which turns an open-ended wait into a bounded one. Provisional rows covers the table design around it.

Questions about blockhash expiry#

How long is a Solana blockhash valid?#

For 150 blockhashes, one per slot that produced a block. At the current 200 ms slot target that is roughly 30 seconds or more, depending on skipped slots.

Can an expired transaction be resent?#

Not as is. The sender has to rebuild it with a new blockhash and sign again, which makes it a new transaction with a new signature.

Does expiry apply to v1 transactions?#

Yes. The v1 format calls the field a lifetime specifier but keeps its meaning.

What expiry cannot settle#

Expiry tells you a transaction can no longer land; it does not tell you whether it already did. Always check status first. It also says nothing for durable nonce transactions, and it can mislead you if your RPC node has pruned the history in question. And it settles nothing about outcomes: a transaction that landed and failed is in the chain even though it did nothing, as landed but failed explains.

Applying the rule#

The reconcile recipe applies this rule in tested code, and transaction signatures as IDs covers the key you settle rows by. To see these transactions arrive before their outcome is known, decode a first transaction from raw shreds.

Sources#

Raw shreds on your own server

Ultra Low Latency Shreds is $200 and Standard Shreds is $100. You pay in crypto, tell us which IPv4 address and UDP port should receive the stream, and we wire it up by hand.