How to Stake Near (NEAR)

How to stake NEAR in 2026: native delegation vs liquid staking vs exchange staking, validator selection, slashing risk, and step-by-step delegation. Beginner-friendly.

What you'll need (prerequisites)

• NEAR held in a self-custodial wallet
• Wallet that supports near staking
• A small native-token reserve for transaction fees
• A shortlist of validators (use the chain's official dashboard)

Step-by-step

1. Step 1: Acquire NEAR

   Buy NEAR on a major exchange (Coinbase, Kraken, Binance) or via a DEX. Withdraw to a self-custodial wallet that supports Near.

2. Step 2: Choose a staking method

   Native staking: delegate directly from your wallet to a validator. Liquid staking: deposit into a liquid-staking protocol and receive a yield-bearing receipt token. Exchange staking: easiest UX but custodial. Pick based on your custody and yield preferences.

3. Step 3: Pick a validator / operator on Near

   For native staking, research validator uptime, commission rate (5-10% is typical), self-stake, and slashing history. Avoid concentrating in the largest validators — distribute to support decentralisation.

4. Step 4: Delegate

   In your wallet's staking tab (or the chain's official dashboard), select the validator and enter the amount. Confirm the transaction. There is usually a small network fee.

5. Step 5: Confirm and monitor rewards

   Rewards typically accrue per epoch (5 mins to 24 hrs depending on chain). Check your validator's performance weekly — if uptime drops, redelegate.

6. Step 6: Unstake when needed

   Unstaking NEAR takes four epochs — epochs target ~12 hours, so expect roughly 2-3 days — and it is a two-step process: unstake, then withdraw once the funds unlock.

How NEAR staking actually works

NEAR's validator set is chosen by stake, and ordinary holders participate by delegating into staking pools — smart contracts run by validator operators. When you call deposit_and_stake on a pool (which is what any wallet staking button does under the hood), your NEAR is held by that contract and counted toward the operator's stake. Because pools are contracts rather than protocol primitives, each operator sets its own commission and its own withdrawal handling, and the quality of the contract deployment matters as much as the quality of the server.

Everything on NEAR is paced by epochs. An epoch is 43,200 blocks, which targets roughly 12 hours in practice. Validator seats are recomputed each epoch, rewards are minted and distributed per epoch, and stake changes take effect at epoch boundaries rather than instantly. NEAR's documentation states plainly that after you delegate, "you will start earning staking rewards after the next epoch" — so a fresh delegation is idle for up to half a day before it begins to compound. Rewards are auto-compounding inside most staking pools: the pool restakes what it earns, and your share of the pool grows rather than a separate claimable balance accumulating.

Unstaking: four epochs, and what that means in wall-clock time

Unstaking NEAR is a two-step process. You first unstake (which stops the position earning and starts the clock), then you withdraw once the tokens have unlocked. NEAR's documentation describes a four-epoch unbonding period before the tokens can be withdrawn. Because epochs target ~12 hours but frequently run longer, and because pools apply their own boundary handling, the widely reported real-world figure is roughly 52–65 hours — call it two to three days, and plan for three.

Two mistakes are common here. The first is assuming unstaking auto-withdraws: it does not, and NEAR sitting in the "unstaked, withdrawable" state inside a pool earns nothing until you actually withdraw it to your account. Check your pool a few days after unstaking and finish the job. The second is unstaking in slices: on many pool implementations a fresh unstake request can restart or extend the clock for the whole pending amount, so decide your full exit size before you start rather than trickling out.

Slashing on NEAR — the honest answer

NEAR's protocol design reserves the right to slash, but slashing is not currently implemented and enforced for delegators or validators: a validator that goes offline, or even one that double-signs, is not penalised by having stake confiscated today. What happens instead is economic exclusion — an underperforming validator is kicked out of the active set and earns nothing for its delegators, and the operator must restake to return. Professional staking providers describe NEAR's slashing risk in exactly these terms, while noting that protocol-level slashing has long been planned for a future upgrade.

Do not read that as "risk-free." The realistic downside is opportunity cost that you may not notice: a validator that is kicked or that runs poorly quietly stops producing rewards while your NEAR remains locked in its pool. And because slashing is a stated future direction, a validator with sloppy key management is a liability you may inherit later. Check your pool's status monthly rather than annually.

Choosing a validator (staking pool)

NEAR's active set is capped, and the entry threshold — the "seat price" — is effectively the stake of the lowest-ranked seat holder. This creates a NEAR-specific risk that does not exist on Cosmos-style chains: a validator sitting just above the seat price can be pushed out when the seat price rises, at which point your delegation stops earning until the operator regains a seat. When you compare pools on NearBlocks, Pikespeak or a comparable explorer, look at the cushion between the operator's total stake and the current seat price, not just at commission.

Then evaluate the usual factors: commission rate and its change history (pool contracts allow the operator to update the fee), uptime and blocks produced across recent epochs, whether the operator runs infrastructure for multiple networks with a public track record, and how much of the network's stake the operator already controls. Concentrating stake in the top two or three pools is bad for the network and bad for your correlated risk.

Minimums, fees and account setup

NEAR has no meaningful protocol minimum for delegators — staking pools accept small deposits — but you must keep NEAR unstaked in your account to pay for transactions and to cover NEAR's storage-staking requirements. Fees on NEAR are fractions of a cent, so the practical floor is low; the real floor is whether a position is large enough to justify checking on it. Use a wallet with native staking support (the NEAR wallet ecosystem, Meteor, or a Ledger-backed setup), and confirm you are interacting with the pool contract address you intended: the pool ID, not a similar-looking name, is the thing that matters.

Where the yield comes from

NEAR staking rewards are funded by protocol issuance, offset by the portion of transaction fees the protocol burns. Because issuance is fixed as a rate and split across all bonded stake, the per-delegator rate falls as the total staked ratio rises and rises when stake leaves. Fee burning means the network's net supply growth can be lower than gross issuance during busy periods, so the gap between nominal APY and real (dilution-adjusted) return varies with activity. Two practical rules follow: read the current rate from a pool explorer rather than a marketing page, and compare pools on net yield after commission, since a 1% versus 10% commission difference matters more than small differences in raw performance.

Liquid staking alternatives for NEAR

The main liquid staking route on NEAR is Meta Pool, which issues stNEAR. You deposit NEAR, receive stNEAR, and the token's value against NEAR increases each epoch as rewards accrue — a "value-accruing" design rather than a rebasing one, so your stNEAR balance stays constant while its redemption value grows. Meta Pool spreads its delegations across a list of validators, which diversifies operator risk relative to picking a single pool yourself, and it runs a stNEAR/NEAR liquidity pool that offers liquid unstake: you can exit immediately by swapping instead of waiting out the four-epoch delay, paying a fee that is set by pool utilisation. Delayed (native) unstaking through Meta Pool still takes the standard protocol wait.

The trade-offs mirror liquid staking everywhere: you accept smart-contract risk, a protocol fee on rewards, and the possibility that stNEAR trades below its redemption value precisely when everyone wants out at once. In exchange you get composability — the receipt token can be used as collateral or in liquidity pools — and an exit that does not require a multi-day wait. If you want to understand the mechanism generally before choosing, see our explainer on what liquid staking is.

Risks worth pricing in

• Seat-price risk. A validator pushed out of the active set stops earning; your stake stays put until you move it.
• Two-step exit. Unstaking is not withdrawing. Funds sit idle until you complete the withdrawal.
• Pool contract risk. Staking pools are smart contracts; a badly deployed or upgraded pool is a real, if uncommon, failure mode.
• Commission drift. Operators can raise fees after you delegate.
• Future slashing. Slashing is not enforced today but has been signalled as a future protocol addition — validator hygiene will start to cost you if it lands.
• Tax treatment. Auto-compounding pools still generate reportable income in most jurisdictions even though nothing is "claimed" — see filing crypto taxes.

Sources

• NEAR Docs — Validator staking and delegation (deposit_and_stake, unbonding, rewards start next epoch)
• NEAR Docs — Epoch (43,200 blocks, ~12 hours)
• P2P.org — NEAR slashing risk (no slashing enforced today; planned for the future)
• Meta Pool Docs — stNEAR, delayed unstake and liquid unstake

Common errors and fixes

• Validator missed blocks. Redelegate to a higher-uptime validator. Use your chain explorer to inspect validator performance metrics before redelegating.
• Slashing event. Native slashing is irreversible. Double-check the validator slashing history before delegating; for liquid staking, the protocol absorbs slashing across the pool.
• Tokens stuck in unstaking. Unstaking has a fixed protocol-level cooldown. Use liquid-staking receipt tokens (e.g. stETH, mSOL, jitoSOL) for instant exit liquidity via DEXes.
• Rewards not accruing. Confirm the delegation transaction succeeded on-chain. Some chains require a separate "claim rewards" transaction; check the chain docs.
• High commission eating yields. Validator commissions can be raised retroactively. Move to a lower-commission operator (typically 3-7%).

FAQ