Start free
AboutMarketplacePricingContactSearch apps
Products
VantageStrataFolioGroundProof
Use cases
Treasury and financePayments and fintechTrading and market makingFunds and researchIssuers and protocolsCompliance and riskResearch and media
Sign inStart free
Dashboard · VantagePlanned

NEAR Network Stats: Transactions, Accounts and NEAR Burned

How much is NEAR used each day, and how much NEAR do its fees burn?

NEAR by day: transactions and the receipts they create, active and new accounts, NEAR burned in gas, rewards to contracts and NEAR staked.

Build it in Studio →Ask for this data
ShareEmail itvoltfincrypto.com/apps/near-network-stats
Blueprint

What the dashboard will show.

The dashboard as it will open in Vantage. Each figure is named here and arrives with its receipt; until its data is published, its place stays empty.

  • Period

Activity

Transactions, receipts, active accounts and new accounts.

Transactions, latest day

count

Transactions included in chunks on the latest complete UTC day.

Figurechain_activity_dailyAwaiting data

Receipts, latest day

count

Receipts executed on the latest complete day, including those created by contract calls and cross-shard steps.

Figurechain_activity_dailyAwaiting data

Active accounts, latest day

count

Distinct accounts that signed transactions on the latest complete day.

Figurechain_activity_dailyAwaiting data

New accounts, latest day

count

Accounts created on the latest complete day: named accounts, implicit accounts and Ethereum-style addresses together.

Figurechain_activity_dailyAwaiting data

Transactions, receipts and accounts by day

count

Transactions, receipts and active accounts by day over the selected period, so the work per transaction can be read from the gap between them.

Line chartchain_activity_dailyAwaiting data

Fees and staking

NEAR burned, gas rewards paid to contracts and NEAR staked with validators.

NEAR burned, latest day

NEAR

NEAR burned in gas on the latest complete day, from the tokens burnt in each execution outcome.

Figurechain_fees_dailyAwaiting data

Gas rewards to contracts

NEAR

The share of function-call gas the protocol paid to the called contracts on the latest complete day.

Figurechain_fees_dailyAwaiting data

NEAR staked

NEAR

NEAR staked with validators at the latest epoch boundary, from the validators call.

Figurestaking_networks_dailyAwaiting data

Validators

count

Validators in the current epoch's set, block producers, chunk producers and chunk validators together.

Figurestaking_networks_dailyAwaiting data

NEAR burned and paid to contracts by day

NEAR

Gas paid each day over the selected period, split into the NEAR burned and the rewards paid to contracts.

Stacked barschain_fees_dailyAwaiting data

Period
Last 30 days, 90 days or a year
About

What it answers, and for whom.

NEAR is a sharded layer 1 with human-readable accounts and keys that apps can hold for their users. This dashboard reads every block and chunk to show how NEAR is used each day: the transactions users signed, the receipts the network executed, active and new accounts, the NEAR burned in gas, the gas paid to contracts and the NEAR staked with validators.

Two NEAR rules shape the figures. One transaction can fan out into many receipts that run across shards in later blocks, so both are counted. And a fee is split: most of the gas is burned, while part of the gas a contract call burns is paid to the contract it called. Every figure is pinned to the block it was read at and links to the reads behind it.

Method

How it will be measured.

Every figure will be read at a block, kept with its source and its exact read, and open a receipt anyone can re-check.

How receipts work →
  1. Transactions are counted when a chunk includes them and receipts when they execute, per UTC day; a transaction that calls several contracts or crosses shards creates several receipts, so both counts are shown.
  2. Active accounts are distinct signers of transactions per day. New accounts are those created by a CreateAccount action or first funded as implicit accounts, split into named, implicit and Ethereum-style addresses.
  3. NEAR burned is the tokens burnt in each execution outcome. Contract rewards are computed from the gas each function call burned and the protocol's reward share, and checked against the called contract's balance change.
  4. NEAR staked and validators come from the validators call at each epoch boundary, and every figure carries a receipt with the block height and hash.

The data it needs

Read from chain state and history

  • chain_activity_dailyTo buildChain activity by dayTransactions, active sending addresses, new addresses, contracts created and gas used on each chain per day, counted from blocks and transactions.
  • chain_fees_dailyTo buildFees and gas by chainFees paid per chain per day in the native token: base fee and priority fee percentiles, total fees, and the share burned where the chain burns fees.
  • staking_networks_dailyTo buildProof-of-stake networksStaked supply, staking ratio, validators and nominal rewards per proof-of-stake network per day.
  • NEAR blocks and chunks: transactions, receipts, gas used, gas limit and gas price per chunk
  • Execution outcomes of transactions and receipts: signer, receiver, actions, gas burnt and tokens burnt
  • CreateAccount actions and first transfers to implicit and Ethereum-style addresses, for new accounts
  • The validators RPC at each epoch: current validators with their stake and their produced against expected blocks and chunks
Questions

Questions people ask.

Why does NEAR count receipts as well as transactions?

A NEAR transaction is turned into one or more receipts, which may execute on other shards in later blocks, and a call that triggers other contracts creates a receipt for each step. Receipts measure the work the network did, while transactions measure what users signed, so the dashboard shows both.

What happens to NEAR gas fees?

Most of each fee is burned. When a transaction calls a contract, part of the gas burned executing that call is paid to the contract's account as a reward for its developer, while the base cost of each receipt is always burned. The dashboard shows the NEAR burned and the rewards to contracts apart.

What are named and implicit accounts?

Named accounts are readable names such as alice.near, created by another account. Implicit accounts are addresses derived from a public key, which exist once they receive NEAR, and Ethereum-style addresses let EVM wallets hold NEAR accounts. The new accounts tile counts every type.

What is storage staking on NEAR?

An account must hold NEAR in proportion to the data it stores on-chain, and that NEAR cannot be spent while the data remains; deleting the data frees it. It is why contracts that hold a lot of state also hold balances that look idle.

Did NEAR change its inflation?

Yes. A protocol upgrade that took effect in October 2025 halved the maximum rate at which new NEAR is issued as staking rewards. The dashboard reads the rewards actually paid each epoch, so the change shows in the staking figures from that date.

Receipt
The unit of execution on NEAR: a transaction becomes receipts, which can run on other shards and create further receipts.
Shard
A part of NEAR's state and load processed in parallel with the others; each block gathers one chunk from every shard.
Implicit account
An account whose address is derived from a public key; it comes into existence when it first receives NEAR.
Access key
A key attached to an account, with full access or limited to calling certain contracts, which lets apps act for users within set limits.
Storage staking
The rule that an account must hold NEAR in proportion to the on-chain data it stores.
Related
All Layer 1 chains apps →

Build NEAR Network Stats: Transactions, Accounts and NEAR Burned on verified data.

Start free in Voltfin Studio: boards, tables and reports where every number opens its receipt. Tell us which data you need first and we will build it next.

Start free →Open live apps