How Long Does It Take to Unstake ETH? Exit Queue Math
A validator exit takes at least 261 epochs, about 27 hours 50 minutes, even with an empty queue, and every 57,600 ETH ahead of you adds a day. On November 3, 2026 the exit queue held 32,643 ETH, so a 32 ETH validator would have waited about 41 hours, plus a payout sweep of up to 7.1 days.
Three constants in the consensus specification produce those numbers. The exit churn limit is capped at 256 ETH per epoch, an epoch lasts 6.4 minutes so there are 225 a day, and a fixed delay of 256 epochs separates the end of the queue from the moment funds become withdrawable. Multiply 256 by 225 and you get 57,600 ETH a day, which is the entire daily capacity of the exit queue, shared by every validator on the network. The exit position is assigned the moment the exit is processed, so a queue that grows afterward cannot push you back, and a queue that shrinks will not pull you forward.
"Unstaking" covers three different requests: skimming rewards, withdrawing part of a large balance, and closing the validator. Skimming never touches the exit queue. A partial withdrawal from a compounding validator and a full exit both do, and both then wait out the 256-epoch delay. The 261-epoch floor, the table of waits for queues of up to 2.5 million ETH, and the comparison with a dated reading of the live queue all follow from the same few constants in the specification.
Four Waits Between a Request and ETH in Your Wallet
A full exit is a sequence of four waits. The first three are set by specification constants plus the size of the queue ahead of you; the fourth depends on where the network's payout pointer happens to be.
| Stage | What the specification does | Length | Constant or function |
|---|---|---|---|
| 1. Lead time | An exit initiated in epoch N cannot take effect before epoch N + 5 | 5 epochs, 32 minutes | compute_activation_exit_epoch = epoch + 1 + MAX_SEED_LOOKAHEAD (4) |
| 2. Exit queue | Your validator's effective balance is charged against 256 ETH per epoch; the exit epoch is the epoch in which the charge is covered | Queue ahead of you divided by 256 ETH, in epochs | compute_exit_epoch_and_update_churn |
| 3. Withdrawability delay | The validator becomes withdrawable a fixed number of epochs after its exit epoch | 256 epochs, 27.3 hours | MIN_VALIDATOR_WITHDRAWABILITY_DELAY |
| 4. Payout sweep | Block proposers pay out withdrawable balances in index order, at most 16 withdrawals per block | 0 to one full cycle, 7.1 days on November 3, 2026 | MAX_WITHDRAWALS_PER_PAYLOAD (16) |
Stages 1 and 3 add up to 261 epochs, which is the 27 hours 50 minutes floor in the opening. Stage 2 is zero extra epochs when the queue is empty and a validator of 32 ETH fits inside the first epoch's budget. Stage 4 is the only one measured in blocks rather than epochs. A figure that stops at "withdrawable" tells you when your validator is eligible to be paid, not when the payment arrives.
The spec text for stages 1 to 3 is short enough to quote. When an exit is initiated, the function sets the exit epoch from the queue calculation and then, in the specification's own code, validator.withdrawable_epoch = validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY. The mainnet configuration file sets that delay to 256 epochs. Nothing in the exit path lets a validator shorten it.
Where 256 ETH Per Epoch Comes From
Before the Electra upgrade on May 7, 2025, the churn limit counted validators: the larger of 4 and the number of active validators divided by 65,536, with activations additionally capped at 8 validators per epoch. Electra changed the unit to ETH, because validators can now hold up to 2,048 ETH and a validator count no longer measures how much stake moves. The replacement has three parts, all in the Electra beacon-chain specification:
get_balance_churn_limit takes the larger of MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA (128 ETH) and the total active balance divided by CHURN_LIMIT_QUOTIENT (65,536), then rounds down to a whole number of ETH.get_activation_exit_churn_limit takes the smaller of MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT (256 ETH) and that value.compute_exit_epoch_and_update_churn uses the result as the per-epoch exit budget.Written as one expression, the exit budget per epoch is min(256 ETH, max(128 ETH, total active balance / 65,536)), rounded down to a whole ETH. The 128 ETH floor and the 256 ETH ceiling are both in force only at the extremes. The table shows how the rule behaves across the range of possible stake, with the draft Glamsterdam rule alongside for comparison (explained in a later section).
| Total active balance (ETH) | Electra rule: ETH per epoch | Electra rule: ETH per day | Draft Glamsterdam rule: ETH per epoch | Draft Glamsterdam rule: ETH per day |
|---|---|---|---|---|
| 4,000,000 | 128 | 28,800 | 128 | 28,800 |
| 8,388,608 | 128 | 28,800 | 256 | 57,600 |
| 10,000,000 | 152 | 34,200 | 305 | 68,625 |
| 16,777,216 | 256 | 57,600 | 512 | 115,200 |
| 20,000,000 | 256 | 57,600 | 610 | 137,250 |
| 30,000,000 | 256 | 57,600 | 915 | 205,875 |
| 44,232,536 (November 3, 2026) | 256 | 57,600 | 1,349 | 303,525 |
| 60,000,000 | 256 | 57,600 | 1,831 | 411,975 |
The thresholds follow from the constants. The floor binds when total active balance is at or below 8,388,608 ETH (128 times 65,536), and the cap binds from 16,777,216 ETH (256 times 65,536) upward. Between them, the limit grows with stake. The ultrasound.money API reported a sum of validator effective balances of 44,232,536 ETH on November 3, 2026, which is 2.6 times the level at which the cap starts to bind. The specification counts active validators only, so the reported sum is a stand-in for total active balance, and the conclusion survives an error of any plausible size. Dividing by 65,536 gives 674.9, so the uncapped value would be 674 ETH per epoch, and the cap cuts it to 256. That has a practical consequence: with stake this far above the threshold, the exit rate does not respond to stake at all. Stake could grow by half and the daily exit capacity would still be 57,600 ETH.
The constants convert to a daily rate through the clock. A slot lasts 12 seconds (SLOT_DURATION_MS is 12,000 in the mainnet configuration) and an epoch has 32 slots, so an epoch is 384 seconds, or 6.4 minutes. A day has 86,400 seconds, which makes 225 epochs, and 225 times 256 ETH is 57,600 ETH a day. The same arithmetic gives 28,800 ETH a day at the 128 ETH floor.
Scale puts the number in context. At 57,600 ETH a day, the exit queue can return 21,024,000 ETH over 365 days, which is 47.5% of the 44.2 million ETH of effective balance. For a third of all staked ETH, about 14.74 million, to leave would take 256 days if every validator that wanted out asked at once. That is a ceiling on aggregate exit speed, not a prediction that anyone will exit at that pace. The ceiling also holds as stake falls: the budget would stay at 256 ETH per epoch until stake dropped below 16.78 million ETH.
The proposal that motivates the next change also explains where the cap came from. EIP-8061 states that EIP-7514 introduced an activation cap of 8 validators per epoch, "now 256 ETH per epoch", and that EIP-7251 extended the same cap to exits. In other words, 256 ETH is 8 validators of 32 ETH each, carried over when the unit changed from validators to ETH.
How the Specification Places One Exit in the Queue
The queue is not a list of waiting validators. It is two numbers in the beacon state: earliest_exit_epoch, the first epoch that still has unspent exit budget, and exit_balance_to_consume, how much of that epoch's budget is left. When a validator exits, compute_exit_epoch_and_update_churn takes the validator's effective balance and does the following:
earliest_exit_epoch and the earliest permitted exit epoch, which is the current epoch plus 5.Two properties follow. First, the queue is first come, first served, and the position is locked in when the exit is processed: later exits receive later epochs and never displace earlier ones. Second, the charge is the validator's effective balance, which is capped at 32 ETH for a validator with 0x01 credentials and at 2,048 ETH for a validator with 0x02 compounding credentials. It is not the actual balance, and it is not what you plan to withdraw.
With Q ETH already ahead of you and an effective balance of E, the exit lands at 4 plus the rounded-up value of (Q + E) divided by 256 epochs after the current one. Q = 0 and E = 32 gives 5 epochs, the lead time with no queue. The same formula for a consolidated validator of 2,048 ETH with an empty queue gives 4 + 8 = 12, because 2,048 ETH needs eight epochs of budget, so the large validator exits 7 epochs, 44.8 minutes, later than a 32 ETH one. A consolidated validator pays for its size in proportion. Its 2,048 ETH uses eight full epochs of budget where a 32 ETH exit uses one eighth of one epoch, the same charge as exiting 64 small validators in one request.
The formula assumes the first epoch's budget is intact. If a queue is already draining, the stored pointer is later than the current epoch plus 5 and the same arithmetic applies from there. The error from the simplification is at most one epoch.
Entry has its own budget. The pending-deposit processing in process_pending_deposits tracks deposit_balance_to_consume and reads the same 256 ETH limit, and exits track exit_balance_to_consume. A queue of a million ETH waiting to be staked does not slow an exit by a single epoch, and a mass exit does not slow deposits. The two queues read the same limit function and nothing else.
Wait Times by Queue Size, Derived From the Constants
The table below applies the formula to queue sizes from empty to 2.5 million ETH. "Queue ahead" is the effective balance already assigned to future exit epochs. Times run from the moment the exit is processed to the moment the validator becomes withdrawable. They exclude the payout sweep, which is covered in the next section. The last column recomputes the 32 ETH case under the draft Glamsterdam exit rule at 44.2 million ETH of stake; it is a scenario, not a forecast, because that rule is not scheduled on mainnet.
| Queue ahead (ETH) | Queue alone at 256 ETH per epoch (days) | 32 ETH validator: epochs to withdrawable | 32 ETH validator: hours | 32 ETH validator: days | 2,048 ETH validator: days | 32 ETH validator under draft Glamsterdam rule: days |
|---|---|---|---|---|---|---|
| 0 | 0.00 | 261 | 27.8 | 1.16 | 1.19 | 1.16 |
| 32,643 (November 3, 2026) | 0.57 | 388 | 41.4 | 1.72 | 1.76 | 1.27 |
| 100,000 | 1.74 | 651 | 69.4 | 2.89 | 2.93 | 1.49 |
| 250,000 | 4.34 | 1,237 | 131.9 | 5.50 | 5.53 | 1.98 |
| 500,000 | 8.68 | 2,214 | 236.2 | 9.84 | 9.88 | 2.80 |
| 1,000,000 | 17.36 | 4,167 | 444.5 | 18.52 | 18.56 | 4.45 |
| 1,500,000 | 26.04 | 6,120 | 652.8 | 27.20 | 27.24 | 6.10 |
| 2,000,000 | 34.72 | 8,073 | 861.1 | 35.88 | 35.92 | 7.75 |
| 2,500,000 | 43.40 | 10,026 | 1,069.4 | 44.56 | 44.60 | 9.40 |
Three rows carry the argument. The first is the floor: with nobody ahead of you, the wait is the 5-epoch lead time plus the 256-epoch delay, 261 epochs. The second row is the November 3, 2026 reading, which lands at 388 epochs, 41.4 hours, because 32,643 ETH of queue takes 127.5 epochs to clear before a 32 ETH validator is added. The row for 2.5 million ETH is a wait of about 44.6 days. The EIP-8061 text recalls an episode in which one large operator's mass exit stretched the exit queue beyond forty days. At 256 ETH per epoch, forty days is a queue of 2,304,000 ETH, so that episode sits between the 2 million and 2.5 million rows.
The 2,048 ETH column barely differs from the 32 ETH column once the queue is long. The extra 7 epochs it takes a large validator to fit, 45 minutes, disappear into a queue measured in days. The size of your own validator matters at the front of the line and almost not at all behind a long queue. What matters in a long queue is how much total stake exits ahead of you, and consolidating into larger validators does nothing to that.
The Glamsterdam column shows what the draft rule does to a queue of the same size. A 500,000 ETH queue that costs a 32 ETH validator 9.8 days under today's rule would cost 2.8 days at 1,349 ETH per epoch. The delay does not change, so the benefit shrinks as a share of the total when the queue is short: for an empty queue the two columns are identical at 1.16 days.
The table describes a request made now against the queue as it stands now. Exits requested after yours take later epochs, so the table needs no forecast of new exits to be right for your own position. It says nothing about what the queue will look like if you decide next week.
The Payout Sweep: Why "Withdrawable" Is Not "Paid"
When the 256-epoch delay ends, the validator's withdrawable_epoch has passed and its balance is eligible to be paid out. The payment happens through the sweep, which is part of normal block processing. In the Electra specification, get_expected_withdrawals builds each block's withdrawal list in two steps. First it serves pending partial withdrawals, at most 8 per payload (MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP). Then it starts at next_withdrawal_validator_index and walks forward through the validator registry, examining up to 16,384 validators (MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP) and stopping when the payload holds 16 withdrawals (MAX_WITHDRAWALS_PER_PAYLOAD). A validator that is fully withdrawable gets its whole balance paid. A validator with excess balance gets the excess. A validator with nothing to pay is passed over without using one of the 16 slots.
Every payload is therefore limited to 16 withdrawals, not 16 validators. The distinction matters because the sweep skips validators that have nothing to withdraw. A validator with 0x00 credentials is not withdrawable at all. A validator with 0x02 credentials and less than 2,048 ETH has no excess to skim. A validator already fully withdrawn has a zero balance. Those entries cost nothing against the 16 slots but are counted against the 16,384-index scan limit, which is far from binding.
At 7,200 slots a day with 16 withdrawals each, the sweep's capacity is 115,200 withdrawals a day, assuming no missed slots. ethereum.org gives the same figure and a table that runs from 3.5 days for 400,000 withdrawals to 7.0 days for 800,000. The dashboard used for the live check below reported a sweep delay of 7.1 days on November 3, 2026, which matches 813,754 active validators divided by 115,200. The table converts validator counts into full-cycle times; its 6.9 days for 800,000 is the unrounded 6.94 that ethereum.org rounds to 7.0.
| Validators paid in one cycle | Blocks per cycle at 16 per block | Full cycle at 16 per block (days) | Average wait (days) | Full cycle at 8 per block (days) |
|---|---|---|---|---|
| 400,000 | 25,000 | 3.5 | 1.7 | 6.9 |
| 800,000 | 50,000 | 6.9 | 3.5 | 13.9 |
| 813,754 | 50,860 | 7.1 | 3.5 | 14.1 |
| 1,000,000 | 62,500 | 8.7 | 4.3 | 17.4 |
| 1,200,000 | 75,000 | 10.4 | 5.2 | 20.8 |
A full cycle is the worst case, not the typical wait. Your validator becomes withdrawable at a random position relative to the pointer, so the wait is uniform between zero and one full cycle, and the average is half of it. If the 7.1-day figure applies, the mean sweep wait is about 3.5 days, and the wait for any particular exit can be anywhere from a few minutes to just over a week. Two forces make the real cycle shorter than the headline arithmetic: validators that produce no withdrawal are skipped (ethereum.org notes that skipping "decreas[es] the time to finish the sweep"), and any validator with 0x02 credentials produces a withdrawal only above 2,048 ETH. One force makes it longer: when the pending-partial queue is full, up to 8 of the 16 slots go to it first, so the sweep may hold 8 slots instead of 16. The "8 per block" column in the sweep table shows what that would do.
Missed blocks slow the sweep in the same way as they slow anything else that happens per block, because a missed slot carries no payload and no withdrawals. Epoch-based timing is unaffected: the queue, the 256-epoch delay and the churn limit are all counted in epochs, which advance with the clock whether or not blocks are proposed.
With no missed slots, the pointer advances through at least 4,800 validators an hour. If your validator sits just ahead of it when it becomes withdrawable, the payout can arrive within an hour of the delay's end. If the pointer has just passed it, the payout waits for a full cycle. The order is set by validator index, with no request or fee that changes it, and the funds go to the address in the validator's withdrawal credentials.
Checking the Arithmetic Against the Live Queue
The derivation predicts specific numbers, so it can be tested. validatorqueue.com publishes the entry and exit queues from beacon-chain data, and its page carries a timestamp. The reading below is the one stamped 13:13 UTC on November 3, 2026. The sum of effective balances (44,232,536 ETH) comes from a separate source, the ultrasound.money API, at slot 15,575,348 (17:49 UTC the same day). Both are third-party readings of chain data, not primary protocol sources, and both will have moved by the time you read this.
| Quantity | Dashboard reading, November 3, 2026 | Derived from the constants |
|---|---|---|
| Exit queue | 32,643 ETH | 127.5 epochs to clear at 256 ETH per epoch, 13.6 hours |
| Exit wait shown | 1 day 16 hours (40 hours) | 13.6 hours + 256 epochs (27.3 hours) = 40.9 hours |
| Entry queue | 1,074,917 ETH | 4,198.9 epochs at 256 ETH per epoch, 18.66 days |
| Entry wait shown | 19 days 4 hours (19.17 days) | 18.66 days, 0.50 days less than shown |
| Churn shown (entry and exit) | 256 ETH per epoch | 256 ETH per epoch (cap binds: 44.2 million ETH is above 16.78 million) |
| Daily cap | not shown | 57,600 ETH |
| Sweep delay shown | 7.1 days | 813,754 active validators / 115,200 per day = 7.06 days |
The exit side lands within an hour on November 3: the queue's own clearing time plus the fixed delay is 0.9 hours more than the 40 hours the dashboard shows. The dashboard does not publish its method, and the six-day history below shows its displayed exit time is not simply queue plus delay. The entry side is half a day longer than the churn arithmetic alone gives, and the constants used here do not account for that half day. The dashboard's own six-day history shows the same offsets:
| Date (2026) | Entry queue (ETH) | Entry wait shown (days) | Entry queue / 57,600 (days) | Entry gap (days) | Exit queue (ETH) | Exit wait shown (days) | Exit queue / 57,600 (days) | Exit gap (days) |
|---|---|---|---|---|---|---|---|---|
| 10-28 | 1,302,430 | 23.09 | 22.61 | 0.48 | 8,666 | 1.19 | 0.15 | 1.04 |
| 10-29 | 1,282,325 | 22.76 | 22.26 | 0.50 | 10,808 | 1.07 | 0.19 | 0.88 |
| 10-30 | 1,238,133 | 21.98 | 21.50 | 0.48 | 3,484 | 1.16 | 0.06 | 1.10 |
| 10-31 | 1,200,897 | 21.33 | 20.85 | 0.48 | 1,142 | 1.09 | 0.02 | 1.07 |
| 11-01 | 1,150,909 | 20.47 | 19.98 | 0.49 | 572 | 1.04 | 0.01 | 1.03 |
| 11-02 | 1,106,767 | 19.71 | 19.21 | 0.50 | 2,077 | 1.11 | 0.04 | 1.07 |
Over six consecutive days the entry gap held between 0.48 and 0.50 days, and the exit gap between 0.88 and 1.10 days, against the 1.14 days that 256 epochs represent. The entry gap is small enough to leave the derivation intact, and it is stated here without an explanation. Both offsets stay in a narrow band while the queues change size, which fits the conclusion that queue size divided by 57,600 a day is what drives the displayed wait. The offsets themselves are left unexplained here.
The entry queue also shows the separation described earlier. With 1.07 million ETH waiting to enter and a 19-day activation wait, the exit queue held 32,643 ETH and a wait of under two days. If the two shared one budget, the exit wait would have been measured in weeks.
Skimming, Partial Withdrawals and Full Exits Are Three Different Paths
Each of the three requests runs through a different part of the specification. Skimming rewards is the only one that skips the exit queue.
| What you want | Validator type | Path in the specification | Exit queue? | 256-epoch delay? | Waits for the sweep? |
|---|---|---|---|---|---|
| Rewards above 32 ETH | 0x01 | Automatic: the sweep pays any excess over 32 ETH | No | No | Yes, the next pass |
| Balance above 2,048 ETH | 0x02 | Automatic: the sweep pays any excess over 2,048 ETH | No | No | Yes, the next pass |
| A chosen amount, keeping at least 32 ETH | 0x02 | Execution-layer withdrawal request with an amount; queued as a pending partial withdrawal | Yes, the amount is charged to the exit budget | Yes | No: pending partials are served first, up to 8 per block |
| Close the validator | 0x01 or 0x02 | Signed voluntary exit message, or an execution-layer withdrawal request with amount 0 | Yes, effective balance is charged | Yes | Yes |
| Any payout | 0x00 | Not payable until credentials are upgraded | Not applicable | Not applicable | Not applicable |
Row 1 is the everyday case. A validator with 0x01 credentials has an effective balance of 32 ETH, and rewards accumulate above that line. The sweep pays the excess to the withdrawal address without any request, so there is no queue. Queue length does not matter to someone who only wants the rewards.
Row 3 is the one that surprises people. In process_withdrawal_request the specification accepts a partial withdrawal only from a validator with compounding credentials. For a compounding validator, it computes the amount to withdraw, calls compute_exit_epoch_and_update_churn with that amount, and adds MIN_VALIDATOR_WITHDRAWABILITY_DELAY to get the withdrawable epoch. The result is queued as a PendingPartialWithdrawal. In effect, a partial withdrawal of 500 ETH from a 2,048 ETH validator takes a place in the same exit queue as a full exit of that size, and then waits the same 256 epochs. Once it is withdrawable, though, the sweep pointer does not matter: pending partials are paid first, at most 8 per block. The validator also keeps at least 32 ETH: the amount is capped at the balance minus 32 ETH minus any other pending withdrawals. A request sent with 0x01 credentials and a non-zero amount is silently ignored.
A few rules interact. A voluntary exit asserts that the validator has no pending partial withdrawals, and an execution-layer full-exit request is dropped without an error when partials are pending. Someone who queued a partial withdrawal and then decides to close the validator must wait for the partial to finish. The request also has to come from the execution address named in the credentials, and it is ignored when the validator has not yet been active for 256 epochs or has already started exiting.
A validator with 0x00 credentials can exit, but the specification's withdrawable test requires an execution-layer credential, so nothing is paid until the credentials are upgraded. ethereum.org says of the prefix that "the account needs upgrading before withdrawals are enabled".
Cases That Do Not Follow the Standard Timeline
Slashing. A slashed validator is forced through the same exit queue, then slash_validator sets its withdrawable epoch to at least the current epoch plus EPOCHS_PER_SLASHINGS_VECTOR, which is 8,192 epochs. That is 36.4 days, against 27.3 hours for an ordinary exit. A slashing penalty is also deducted immediately. The slashing path is a consequence of provable misbehavior and is not an option anyone picks.
Ejection. process_registry_updates initiates an exit for any active validator whose effective balance has fallen to 16 ETH or below (EJECTION_BALANCE). An ejected validator joins the ordinary queue and waits like any other, so a long-running inactivity penalty does not bypass the line.
Minimum activity. A voluntary exit and an execution-layer withdrawal request both require the validator to have been active for SHARD_COMMITTEE_PERIOD, which is 256 epochs, 27.3 hours. For a long-running validator this does not matter. For a validator that was activated yesterday it does, and the requirement is a check on the request, not an extra queue.
The validator keeps working until its exit epoch. Exit does not take effect when the request is processed. The validator is active for epochs from activation_epoch up to but not including exit_epoch, so during the queue wait it remains in the active set with its normal duties. The 256 epochs after exit are different: the validator is no longer active, has no duties, and is waiting only for the withdrawable epoch.
Slot time. Every duration above is in epochs. A work-in-progress feature specification for EIP-8198, which would shorten slots, rescales the churn per epoch so that the per-day rate stays constant, while leaving the 256-epoch delay at 256 epochs. If that were ever adopted, the delay would shrink in wall-clock terms. It has no fork epoch in the mainnet configuration.
Consolidation. Moving stake from many small validators into one 0x02 validator uses a separate consolidation budget, not the exit budget. Consolidating therefore does not lengthen the exit queue. The reverse trip, splitting a large validator, is a partial withdrawal plus new deposits, and it passes through the exit queue and the entry queue in turn.
What Fusaka and Glamsterdam Do to the Cap
Fusaka, the Fulu consensus upgrade, activated on mainnet at epoch 411,392, December 3, 2025 at 21:49:11 UTC according to the mainnet configuration. It does not change the churn. The Fulu beacon-chain specification modifies process_pending_deposits only to remove support for the former deposit mechanism, and the function it modifies still reads get_activation_exit_churn_limit. The live dashboard agrees: it shows 256 ETH per epoch on both queues.
Glamsterdam is the next planned upgrade, the pairing of the Amsterdam execution-layer fork with the Gloas consensus-layer fork. Its list of scheduled EIPs, in the Glamsterdam meta EIP (EIP-7773, status Review when checked), includes EIP-8061, "Increase Exit and Consolidation Churn". The Gloas specification is marked as containing draft EIPs that "may change or be removed". The draft changes three things:
CHURN_LIMIT_QUOTIENT_GLOAS halves the quotient to 32,768, so the base budget doubles.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS), but exits lose the cap. get_exit_churn_limit is the larger of 128 ETH and total active balance divided by 32,768, rounded down to a whole ETH.At 44,232,536 ETH, the draft exit rule gives 1,349 ETH per epoch, or about 1,350, and 303,525 ETH a day. That is 5.3 times the present 57,600 ETH a day; EIP-8061 describes the change as roughly a quadrupling, and the multiple depends on the stake level. Unlike the Electra rule, it keeps scaling: at 30 million ETH of stake it would be 915 ETH per epoch, and at 60 million it would be 1,831. The queue part of every row in the wait table shrinks by the same factor of 5.27, while the 256-epoch delay does not change, so the floor for any exit stays at 261 epochs. The "third of the stake" illustration becomes 48.6 days at that rate, down from 256, holding stake constant.
What is settled and what is not, as of November 3, 2026:
GLOAS_FORK_EPOCH is 18,446,744,073,709,551,615, the placeholder for "not scheduled".Until a mainnet date is announced and clients ship it, the working assumption is the Electra rule: 256 ETH per epoch. A planned upgrade can still change, and Glamsterdam's block-building changes (EIP-7732) alter how withdrawals are assembled in a payload, adding builder withdrawals that share the 16-withdrawal limit. The sweep arithmetic above is derived for the Electra rules. This guide does not derive the sweep under Gloas. The Heze beacon-chain specification file, which the mainnet configuration lists after Gloas, lists EIP-7805, EIP-8015 and EIP-8365 and does not mention churn.
What the Queue Means for Staking Products
The protocol's exit queue is a limit on how fast ETH can leave the validator set in aggregate. It is not a description of any particular product. Someone holding a liquid staking token, an ETF share or a custodial staking account is relying on that product's own redemption terms, and those terms may or may not involve the protocol queue. A product with a liquidity buffer can pay redemptions from a reserve and leave validators in place. A product that has to unwind validators to meet redemptions inherits the queue, the 256-epoch delay and the sweep, in that order, and the arithmetic in this guide is the floor on how fast it can do that.
Because the queue is a rate limit, it works as a stress indicator rather than a verdict. A long entry queue means more ETH wants to start staking than the protocol will activate, and a long exit queue means more ETH is trying to leave than the protocol will release. Neither says anything about price. The existing guides on staking yield and its risks and on staking-enabled ETFs cover the product side, including how funds hold liquidity buffers. The proof-of-work versus proof-of-stake explainer, one of the guides in the Learn hub, covers why a proof-of-stake network rate-limits validator changes at all.
Two risk notes follow from the mechanics. First, staked ETH is not instantly liquid even at the protocol level: the fastest possible return, with an empty queue, is a little under 28 hours plus the sweep, and a stressed queue can be weeks long. Second, the exit functions described above assign the exit epoch at the moment of processing and contain no cancellation step. Someone who exits during a short queue locks in the short wait, and someone who waits for a better moment accepts whatever queue exists then.
Taxes sit outside the protocol arithmetic. Whether a payout is income, a return of capital or something else depends on the jurisdiction and the facts. The guides on staking reward taxation in the United States and in Canada cover the treatment of rewards, and the walkthrough on reading a transaction in a block explorer covers looking up the receiving address once a payout lands.
Estimating Your Own Exit From Two Numbers
Everything in the wait table comes from four steps, which fit in a spreadsheet cell or a few lines of code.
The estimate has three weak points. The queue figure on any dashboard is a reading at one moment, and the dashboard's own arithmetic is not published. The effective balance, not the displayed balance, is what counts. And the sweep position is unknowable in advance. If a result matters to a decision, the beacon chain exposes each validator's exit epoch and withdrawable epoch once the exit is processed, and those two numbers settle the question for that validator.
Frequently Asked Questions
How long does it take to unstake ETH?
The minimum is 261 epochs, about 27 hours 50 minutes, plus the payout sweep. That minimum assumes an empty exit queue. Every 57,600 ETH ahead of you in the queue adds one day. On November 3, 2026, with 32,643 ETH queued, a 32 ETH validator would have been withdrawable after about 41 hours, and the sweep adds from a few minutes up to roughly a week.
What is the Ethereum exit queue?
It is the schedule of future exit epochs that the protocol assigns to validators that have asked to leave. Each epoch can release at most 256 ETH of effective balance, so a validator whose exit does not fit is assigned a later epoch. The queue is first come, first served, and the position is fixed when the exit is processed.
Is staked ETH locked?
Since the Capella upgrade in April 2023, a validator with execution-layer withdrawal credentials can exit and receive its balance, so the lock is not permanent. A validator with 0x01 credentials also has rewards above 32 ETH paid out automatically by the sweep without a request. The exit itself is rate-limited and takes at least 261 epochs.
Why does the entry queue look so much longer than the exit queue?
They are separate queues with separate budgets, each limited to 256 ETH per epoch. On November 3, 2026 the entry queue held 1,074,917 ETH, a wait of about 19 days on the dashboard, while the exit queue held 32,643 ETH. The difference is demand, not capacity: more ETH was waiting to start staking than to stop.
Does a bigger validator wait longer to exit?
A 2,048 ETH validator exits 7 epochs, about 45 minutes, later than a 32 ETH validator when the queue is empty. The queue charges effective balance, so the large validator needs 8 epochs of budget where the small one needs a fraction of one. Behind a queue of days, the difference is invisible.
Will Glamsterdam shorten the exit queue?
The draft rule in EIP-8061 would remove the 256 ETH cap on exits and scale them with stake, which at 44.2 million ETH is about 1,350 ETH per epoch. The fixed 256-epoch delay would stay. As of November 3, 2026, no mainnet date had been set, and the Hoodi test activation had been postponed.
General educational research from CryptosEyes, not investment, tax or legal advice. It recommends no staking provider or product and takes no view on whether to stake, hold or exit. Protocol parameters, queue sizes and fork schedules change, and the live figures here are readings from November 3, 2026. Staking carries risks that include slashing, smart-contract and custody risk at any intermediary, and delays in getting funds back.
Sources
Primary documents, market context, and methodology references behind this article.
get_balance_churn_limit, get_activation_exit_churn_limit, compute_exit_epoch_and_update_churn, initiate_validator_exit, process_withdrawal_request, process_voluntary_exit, get_expected_withdrawals, slash_validator. Main branch at commit 204fb4a (November 2, 2026); text identical to tag v1.7.0-beta.4. Checked November 3, 2026.
CHURN_LIMIT_QUOTIENT 65,536; MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA 128 ETH; MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT 256 ETH; MIN_VALIDATOR_WITHDRAWABILITY_DELAY 256; Electra and Fulu fork epochs; Gloas fork epoch unset. Checked November 3, 2026.
compute_activation_exit_epoch, MAX_SEED_LOOKAHEAD, SLOTS_PER_EPOCH, EPOCHS_PER_SLASHINGS_VECTOR, EFFECTIVE_BALANCE_INCREMENT, get_validator_churn_limit. Checked November 3, 2026.
MAX_WITHDRAWALS_PER_PAYLOAD (16) and MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP (16,384). Checked November 3, 2026.
Fusaka changes; process_pending_deposits still reads get_activation_exit_churn_limit. Checked November 3, 2026.
get_exit_churn_limit, get_activation_churn_limit, CHURN_LIMIT_QUOTIENT_GLOAS; draft status note; builder withdrawals in get_expected_withdrawals. Checked November 3, 2026.