What Is NEAR Token: TPS, Speed & How It Works

Key Takeaways

• NEAR Protocol is a Layer 1 proof-of-stake blockchain launched on mainnet in April 2020
• NEAR supports a theoretical throughput of ~100,000 transactions per second using Nightshade sharding (tied to full Phase 2 deployment)
• NEAR produces a new block approximately every second, with transaction finality in ~1–2 seconds
• NEAR's theoretical TPS ceiling surpasses Ethereum's base layer (~15–30 TPS) and Solana's published peak (~65,000 TPS)
• Chain abstraction is NEAR's active strategic direction for 2024–2025, positioning the network beyond raw TPS benchmarking

What Is NEAR Protocol?

NEAR Protocol is a Layer 1 proof-of-stake blockchain designed for high-throughput, low-cost decentralized applications (dApps). Launched on mainnet in April 2020 by the NEAR Foundation, it uses a proprietary sharding mechanism called Nightshade to support a theoretical throughput of ~100,000 transactions per second. NEAR supports smart contracts in Rust and JavaScript, making it accessible to both blockchain-native developers and the broader Web3 community.

The NEAR blockchain operates as a Layer 1 (L1) network, meaning it runs independently with its own consensus mechanism, native token, and security model. It sits in the same category as Ethereum and Solana, providing the foundational infrastructure that decentralized applications are built on. Unlike Layer 2 networks that depend on an existing chain for security, NEAR handles everything at the base layer. Aurora, an EVM-compatible environment built on top of NEAR, is a Layer 2 product and distinct from NEAR's own L1 architecture.

The NEAR token (ticker: NEAR) is the network's native cryptocurrency. The token pays gas fees for transactions and smart contract execution, stakes for validator participation, and participates in on-chain governance. The NEAR token is separate from NEAR Protocol the network. Whenever you see "NEAR" in a tokenomics or market context, it refers to the token; when you see it in an architectural context, it refers to the network.

Development on NEAR Protocol began in 2018, with mainnet launching in April 2020. The network is governed by the NEAR Foundation, a non-profit organization based in Switzerland. NEAR's TPS performance is anchored by its Nightshade sharding architecture, which the following sections explain in full.

What Is TPS and Why Does It Matter for Blockchain?

Transactions per second (TPS) measures how many individual transactions a blockchain network can validate and finalize within a single second. It is the primary performance benchmark for evaluating whether a blockchain can support high-volume real-world use cases.

TPS matters because the practical ceiling of a blockchain determines what applications can run on it. A DeFi trading protocol needs rapid transaction finality to execute market orders reliably. A slow blockchain creates failed trades, delayed settlements, and poor user experience. Similarly, a mass-market payment application needs to process thousands of transactions per second to function at consumer scale.

This throughput challenge has a name in blockchain research: the scalability trilemma, a concept associated with Vitalik Buterin. The trilemma states that blockchains typically cannot achieve decentralization, security, and scalability simultaneously. Improving one tends to compromise another. Early blockchains like Bitcoin and Ethereum prioritized decentralization and security, which capped their scalability. Ethereum's base layer processes approximately 15–30 transactions per second as a result. NEAR Protocol positions Nightshade sharding as its architectural response to the trilemma without sacrificing decentralization or security.

This is the challenge NEAR Protocol was designed to address. Here is what NEAR's TPS actually looks like and how it gets there.

How Fast Is NEAR Protocol? NEAR Protocol TPS Explained

NEAR Protocol supports a theoretical throughput of ~100,000 transactions per second, powered by Nightshade sharding, with blocks produced approximately every second and transaction finality in ~1–2 seconds. That figure represents the Phase 2 ceiling of Nightshade's phased rollout. Real-world TPS scales with the number of active shards currently deployed.

Key NEAR Protocol performance stats:

Theoretical TPS vs. Real-World TPS

Two distinct measurements define blockchain speed claims: theoretical TPS and real-world TPS. Understanding both prevents the most common error in blockchain performance reporting.

Theoretical TPS is the mathematical performance ceiling a network can reach under ideal conditions with full infrastructure deployed. Real-world TPS, also called sustained TPS, reflects actual throughput under live network conditions with the current state of deployment. These two figures diverge on every blockchain in the industry.

NEAR Protocol's theoretical TPS ceiling is approximately 100,000 transactions per second. That figure is achievable with full Nightshade Phase 2 dynamic sharding implementation. Real-world TPS is lower today, dependent on the number of active shards deployed as Nightshade's phased rollout continues. Most articles cite NEAR's theoretical ceiling as a flat fact. A more precise reading explains what that figure means and when it becomes fully available. Every blockchain's published TPS is a theoretical ceiling, not a guaranteed operational throughput.

How Nightshade Sharding Powers NEAR's Speed

Think of a traditional single-chain blockchain as a one-lane highway. Every transaction must travel the same road in sequence. When traffic builds, everything slows. Nightshade sharding adds parallel lanes to that highway. Each lane (shard) processes its own stream of transactions simultaneously, and the total road capacity scales with the number of lanes added.

Nightshade sharding is NEAR Protocol's proprietary dynamic sharding mechanism. It splits the blockchain's state and transaction processing across multiple parallel shards, each producing a "chunk" of each block. Shards process transactions simultaneously rather than sequentially, multiplying NEAR's total throughput and enabling a theoretical ceiling of ~100,000 TPS with full Phase 2 implementation.

NEAR Protocol achieves high TPS through the following process:

1. NEAR's blockchain state is divided across parallel shards
2. Each shard independently processes its assigned transactions
3. Each shard produces a "chunk," its portion of each block
4. Chunks are assembled into a complete block
5. Total throughput scales proportionally with shard count, enabling ~100,000 TPS at full Nightshade Phase 2 implementation

Without sharding, every validator must process every transaction, creating a throughput ceiling. Nightshade sharding removes this bottleneck by splitting transactions across parallel shard groups, so each group processes only its portion of the total transaction load. The result is that total TPS scales proportionally with the number of active shards.

NEAR's high throughput has a direct practical benefit for users: lower gas fees. When a network can process transactions efficiently without congestion, there is no need to outbid other users for block space. NEAR's gas fees typically run less than $0.01 per transaction, compared to Ethereum's fees that frequently reach several dollars during periods of congestion. For a deeper look at Nightshade sharding, the NEAR Foundation's technical blog provides the full architectural breakdown.

NEAR Protocol Block Time and Finality

NEAR Protocol produces a new block approximately every second, with transaction finality (the point at which a transaction is confirmed as irreversible) achieved in approximately 1–2 seconds under normal network conditions. This compares favorably to Ethereum's ~12 second block time and positions NEAR well for applications requiring near-real-time transaction confirmation.

For DeFi applications, fast finality is a practical requirement, not a technical curiosity. Order books, liquidation mechanisms, and AMM swaps all depend on rapid confirmation that a transaction has settled. Solana achieves a faster block time of approximately 400ms, though its network has experienced documented periods of downtime that developers should factor into reliability assessments.

NEAR Protocol TPS vs. Competitors

NEAR Protocol competes in the Layer 1 blockchain space alongside Ethereum, Solana, Avalanche, Polkadot, and other L1 networks, each with distinct architectural approaches to the scalability challenge.

All TPS figures are theoretical maximums under ideal conditions. Real-world sustained TPS varies for all networks. Ethereum L1 figures exclude Layer 2 scaling solutions (Optimism, Arbitrum, Base, among others), which significantly increase Ethereum's effective throughput.

Solana currently posts a theoretical TPS of approximately 65,000 through single-chain optimization using Proof of History plus Proof of Stake consensus. NEAR Protocol's theoretical ceiling of ~100,000 TPS with full Nightshade Phase 2 deployment is higher, but it requires that full deployment to be realized. The key architectural difference is that NEAR's TPS ceiling scales horizontally with shard count as demand grows, while Solana's single-chain design places a natural ceiling on further scaling. Solana has experienced documented periods of network downtime that developers should weigh as a reliability consideration. Neither network's TPS figure should be treated as a guaranteed operational throughput.

Comparing NEAR to Ethereum's base layer shows a substantial performance gap: NEAR's ~100,000 theoretical TPS versus Ethereum's ~15–30 TPS, alongside NEAR's ~1 second finality versus Ethereum's ~12 second block time. Ethereum's L2 ecosystem significantly increases Ethereum's effective throughput beyond its L1 baseline, so the fair comparison is L1 to L1. Comparing NEAR's L1 TPS to Ethereum's full stack would be misleading.

Avalanche uses a subnet architecture, where application-specific subnetworks parallelize workloads rather than sharding a unified chain state. Polkadot uses a parachain model, where independent blockchains share security rather than processing within one sharded state. Both represent distinct approaches to scalability, each with different tradeoff profiles compared to NEAR's Nightshade sharding.

How Does NEAR Protocol Work? Architecture Overview

Here is how NEAR Protocol works at a high level: when a transaction is submitted to NEAR, it is routed to one of the network's active shards based on the accounts involved. Validators assigned to that shard process the transaction and produce a chunk, their portion of the current block. All shards produce their chunks simultaneously, and the resulting block is assembled from those chunks. Transaction finality is achieved in approximately 1–2 seconds under normal network conditions.

This architecture rests on three pillars: Nightshade sharding for throughput scalability, Thresholded Proof-of-Stake consensus for security and validator selection, and multi-language smart contract support for developer accessibility.

Nightshade Sharding Phases: How NEAR Scales Over Time

Sharding originates in database engineering, where large datasets are split across multiple servers for parallel processing. Applied to blockchain, sharding splits a network's transaction workload across parallel segments called shards, so each validator processes only its assigned portion rather than the full transaction set. This removes the throughput ceiling that single-chain blockchains face.

NEAR's TPS ceiling is not a fixed figure. It is tied to the progressive rollout of Nightshade sharding across three phases, and understanding that progression explains both the ~100,000 TPS figure and its current context.

Phase 0 (Simple Nightshade): Launched with NEAR's mainnet. A single shard processes all transactions, with all validators participating. This phase established the sharding framework and infrastructure without yet enabling parallel processing.

Phase 1 (Sharding with Single-Shard Tracking Nodes): The blockchain's state is distributed across multiple shards. Validators are assigned to specific shards rather than processing all transactions network-wide. This is the current deployment phase, and it delivers meaningful throughput improvements over Phase 0.

Phase 2 (Full Dynamic Resharding): Shards can dynamically split and merge based on network load. The full TPS ceiling is unlocked. This phase enables theoretically unbounded scalability by adding shards as demand grows, making the ~100,000 TPS figure a product of full Phase 2 realization rather than current operational performance.

Each phase adds more parallelism to NEAR's transaction processing, with Phase 2 representing the full realization of Nightshade's design. The ~100,000 TPS figure refers to NEAR's Phase 2 theoretical ceiling, not the current operational TPS under Phase 1. For the technical details behind Nightshade sharding, the official documentation from NEAR Foundation provides the full specification.

Proof-of-Stake Consensus: How NEAR Validates Transactions

NEAR Protocol uses Thresholded Proof-of-Stake (TPoS), a variant of Proof-of-Stake where validator seats are awarded based on the amount of NEAR tokens staked, with approximately 100 active validators securing the network at any given time.

Validators stake NEAR tokens as collateral to earn the right to produce block chunks for their assigned shard. The "threshold" is the minimum stake required to qualify for a validator seat. Validator seats are periodically re-allocated based on stake weight, creating a market-driven selection process. Because NEAR operates on Proof-of-Stake, validators perform computations proportional to network activity rather than arbitrary computational puzzles, making NEAR significantly more energy-efficient than chains built on Proof-of-Work.

NEAR token holders who do not operate validator nodes can delegate their stake to existing validators and receive a share of staking rewards. This delegated staking option makes network participation accessible to non-technical users. Because NEAR has always operated on Proof-of-Stake, the network uses validators and staking rather than the computational mining found in Proof-of-Work chains like Bitcoin.

Smart Contracts and Developer Tools on NEAR

NEAR Protocol supports smart contracts written in Rust (for performance-critical applications) and JavaScript/TypeScript via AssemblyScript, making the network accessible to the estimated 12+ million JavaScript developers worldwide without requiring them to learn a blockchain-specific language. This is a meaningful developer adoption differentiator compared to Ethereum's Solidity-first environment. Developers building Web3 applications (decentralized apps, or dApps) on NEAR can write contract logic in familiar languages, reducing the barrier that slows adoption on other L1 platforms.

What Can You Do on NEAR Protocol? Use Cases and Ecosystem

NEAR Protocol supports a growing range of decentralized applications across DeFi, NFTs, gaming, developer tooling, and payments:

• DeFi applications: Ref Finance, NEAR's native decentralized exchange (DEX), enables on-chain trading with low gas fees
• NFT marketplaces: Paras enables low-cost NFT minting and trading on NEAR's infrastructure
• EVM-compatible development: Aurora, an EVM-compatible Layer 2 on NEAR, allows Ethereum smart contracts to run on NEAR
• Cross-chain transfers: The Rainbow Bridge moves assets between the Ethereum network and NEAR
• Web3 application development: Rust and JavaScript smart contract support covers a broad developer audience
• Gaming and micropayments: Sub-cent gas fees make high-frequency transaction use cases economically viable

NEAR's high TPS and fast finality are prerequisites for functional DeFi. Order books, automated market maker (AMM) swaps, and liquidation engines require rapid transaction settlement to function reliably. Ref Finance operates as NEAR's primary native DEX, benefiting directly from the network's throughput and low gas costs. Gas fees below $0.01 per transaction make DeFi participation accessible to smaller traders who cannot economically participate when Ethereum fees are elevated.

Aurora is an EVM-compatible Layer 2 environment built on NEAR Protocol, not part of NEAR's own L1 architecture. It allows Solidity developers to deploy Ethereum smart contracts on NEAR's infrastructure, accessing NEAR's throughput and low fees without rewriting existing contract code. This is a meaningful adoption channel for the large developer community building on Ethereum. The Rainbow Bridge provides trustless cross-chain asset transfers between Ethereum and NEAR, enabling users to move ERC-20 tokens and other assets between ecosystems without relying on a centralized custodian.

The NEAR token powers each of these use cases. It pays gas fees for transactions and smart contract execution, stakes for validator participation or delegated staking rewards, and participates in on-chain governance. Developers also stake NEAR to pay for on-chain storage, a model that separates storage costs from computation costs and gives developers predictable resource pricing. NEAR's high throughput is what makes each of these applications economically and technically viable at scale.

Who Built NEAR Protocol? Founders and Team Credibility

NEAR Protocol was co-founded by Illia Polosukhin and Alexander Skidanov. Polosukhin, a former software engineer and researcher at Google Brain, co-authored the landmark 2017 paper "Attention Is All You Need" (Vaswani et al.), the foundational AI research that introduced the Transformer architecture now powering ChatGPT, GPT-4, and virtually every modern large language model. Polosukhin is one of eight co-authors on the paper. He co-authored this research while at Google before leaving to build NEAR.

Co-founder Alexander Skidanov brings deep expertise in distributed systems and database engineering, with prior engineering roles at Microsoft and MemSQL, a high-performance distributed database company whose sharding concepts directly informed NEAR's Nightshade architecture. The architectural parallels between distributed database sharding and blockchain state sharding are not coincidental.

NEAR Protocol is governed by the NEAR Foundation, a non-profit organization based in Switzerland that stewards the network's development, ecosystem grants, and governance programs. The foundation supports NEAR Protocol's open-source development and coordinates with the global NEAR developer community. For a full overview of NEAR's organizational structure and ongoing projects, the NEAR Foundation website is the primary reference point.

NEAR Protocol and Chain Abstraction: What Comes Next

Chain abstraction refers to a design philosophy in blockchain infrastructure where users and developers interact with decentralized applications without needing to know, or actively manage, which underlying blockchain is processing their activity. Rather than selecting a wallet, managing separate gas tokens, and bridging assets between chains manually, users simply use an application and the underlying chain routing happens without their direct involvement.

As the blockchain ecosystem grows increasingly multichain, user experience fragmentation has become the primary barrier to mainstream adoption. Managing multiple wallets, gas tokens, and bridge protocols creates friction that discourages non-technical users from participating. NEAR's chain abstraction vision positions it not just as a high-performance L1 but as a coordination layer for a multichain ecosystem, where NEAR's Nightshade throughput provides the speed foundation for cross-chain activity at scale. Chain abstraction is NEAR's active development direction for 2024–2025, not a delivered product, but it represents a meaningful evolution of NEAR's positioning beyond raw TPS benchmarking.

Frequently Asked Questions About NEAR Protocol

What is NEAR Protocol?

NEAR Protocol is a Layer 1 proof-of-stake blockchain launched on mainnet in April 2020. It uses a proprietary sharding mechanism called Nightshade to support a theoretical throughput of ~100,000 transactions per second. NEAR supports smart contracts in Rust and JavaScript and is governed by the NEAR Foundation, a non-profit based in Switzerland.

How many transactions per second can NEAR process?

NEAR Protocol supports a theoretical throughput of ~100,000 transactions per second under full Nightshade Phase 2 dynamic sharding implementation. Real-world sustained TPS is lower and depends on the number of active shards currently deployed. The ~100,000 figure is the Phase 2 ceiling, which is in active deployment.

How does NEAR Protocol achieve high TPS?

NEAR achieves high TPS through Nightshade sharding: (1) the blockchain state is divided across parallel shards; (2) each shard processes its assigned transactions independently; (3) each shard produces a "chunk," its portion of the block; (4) chunks are assembled into a complete block; (5) total throughput scales proportionally with shard count, enabling ~100,000 TPS at full Phase 2 implementation.

Is NEAR Protocol faster than Solana?

Solana currently posts a theoretical TPS of approximately 65,000 through single-chain optimization. NEAR Protocol's theoretical ceiling of ~100,000 TPS with full Phase 2 Nightshade deployment is higher, but requires that full deployment to be realized. The key differentiator is architectural: NEAR's TPS scales horizontally as shard count grows, while Solana's single-chain design imposes a ceiling on further scaling.

What is Nightshade sharding in NEAR?

Nightshade is NEAR Protocol's proprietary dynamic sharding mechanism. It splits the blockchain's state across parallel shards, each producing a "chunk" of each block. Shards process transactions simultaneously rather than sequentially, multiplying total throughput. The full ~100,000 TPS ceiling requires Phase 2 full dynamic resharding implementation.

Who created NEAR Protocol?

NEAR Protocol was co-founded by Illia Polosukhin and Alexander Skidanov. Polosukhin co-authored the 2017 paper "Attention Is All You Need" (Vaswani et al.) while at Google Brain, the research that introduced the Transformer architecture underlying modern AI systems. Skidanov brings distributed systems expertise from Microsoft and MemSQL. The network is governed by the NEAR Foundation.

What is the block time of NEAR Protocol?

NEAR Protocol produces a new block approximately every second, with transaction finality achieved in approximately 1–2 seconds under normal network conditions. This compares to Ethereum's ~12 second block time, making NEAR substantially faster for latency-sensitive applications such as DeFi order books and real-time payments.

What consensus mechanism does NEAR Protocol use?

NEAR Protocol uses Thresholded Proof-of-Stake (TPoS), a variant of Proof-of-Stake where validator seats are awarded based on the amount of NEAR tokens staked. Approximately 100 active validators secure the network at any given time. Because TPoS requires no computational mining, NEAR is significantly more energy-efficient than Proof-of-Work chains.

NEAR Protocol combines a theoretical throughput of ~100,000 transactions per second through Nightshade sharding, sub-cent gas fees, and smart contract support in Rust and JavaScript to position itself as a scalable Layer 1 blockchain for Web3 development. With chain abstraction as its 2024–2025 strategic direction, NEAR is building beyond raw TPS benchmarks toward a role as a multichain coordination layer.

To explore NEAR Protocol further: visit near.org for the official overview, the official documentation for technical specifications, or near.org/developers to explore building on NEAR.

This article is for educational and informational purposes only. Nothing in this content constitutes financial advice or a recommendation to purchase, sell, or hold any cryptocurrency. Always conduct your own research before making financial decisions.