Indexed NEARBlockchain Data
NEAR runs a sharded proof-of-stake Layer 1 where accounts are readable names and execution is asynchronous, a transaction becoming receipts that finish in later blocks and other shards.
How to query NEAR data with SonarX
Instant Data Share
Available todaySnowflake, and file dumps to your object storage
Query NEAR blockchain data with plain SQL from a live database inside your own Snowflake account, populated with the indexed chain dataset. There is no pipeline to build and no second copy to store. The same dataset ships as file dumps to your own object storage for lakes and warehouses that are not Snowflake.
- Full history as a Snowflake data-share
- File dumps to S3 or your own object storage
- Real-time delivery, current to chain tip — on request
Used for:
- Analytics teams already on Snowflake that want NEAR data beside their existing tables
- Fund accounting and treasury reporting that reconciles against a fixed history
- Cross-chain questions answered in one SQL statement instead of one query per chain
- Loading NEAR history into BigQuery, Databricks, Redshift or a Spark lake
- Replacing a self-hosted indexer and the engineering time that keeps it running
- Serving one governed dataset to several desks without copying it per team
Curated Datasets
Available todayPurpose-built tables
Protocol-level NEAR datasets modelled for one job, so the decoding and the joins are done before the data reaches you.
- DeFi
- Staking
Used for:
- Position-level NEAR lending, swap and liquidity analysis
- Reward, delegation and validator reporting without rebuilding the model
- Token distribution, holder and payment-flow reporting
- Risk and exposure work that needs protocol state, not raw logs
- Skipping the decoding layer an in-house team would have to maintain
- Extending an existing NEAR share with a modelled slice
Balances
Enabled on requestTables and REST
Read what a NEAR address held, either as it stands now or exactly as it stood at a past block or timestamp.
- Point-in-time balance tables, as at any block or timestamp
Used for:
- Reconstructing NEAR portfolios and NAV as at a reporting date
- Audit and reconciliation work that has to be repeatable months later
- Wallet and portfolio products that render NEAR balances on page load
- Compliance checks that read one NEAR address at one block height
- Refreshing holdings for a whole book of accounts on a schedule
- Tax and cost-basis workflows that need holdings at each event
Realtime API
Enabled on requestREST over the indexed dataset
Query indexed NEAR records over REST, reading the same dataset the share reads, with no warehouse in the path.
Used for:
- Applications that need one answer rather than a table scan
- Customer-facing screens where query latency is visible to a user
- Services that have no data warehouse and do not want to run one
- Prototyping against production data before committing to a share
- Backend checks that run per request instead of per batch
- Teams that want indexed NEAR data behind their own API layer
NEAR data: frequently asked questions
What is NEAR?
NEAR’s mainnet has produced blocks since 2020, under Nightshade, a proof-of-stake protocol that splits the chain’s state across shards. A block here is a container: it holds one chunk per shard, and a transaction sits in the chunk of the shard that owns its account. Contracts compile to WebAssembly rather than to EVM bytecode, and NEAR is the native token, divisible into a septillion yoctoNEAR. Two design choices shape everything about the data. Accounts are readable names with subaccounts beneath them, and each account can hold several access keys, including keys restricted to calling one method on one contract, so identity is a hierarchy and a permission set rather than a single hash. And execution is asynchronous: a signed transaction is converted into a receipt, and a receipt that calls another contract produces further receipts that run in later blocks, sometimes on another shard. Accounts also pay for the state they occupy by locking NEAR against the bytes they store, so part of a balance is never spendable.
NEAR data on SonarX
SonarX indexes NEAR through the structures the protocol actually uses: blocks and the chunks inside them, transactions and the receipts they generate, execution outcomes with their gas, contract calls with their arguments and logs, access-key changes, staking records, and derived balances. Everything is normalized into the model SonarX uses across every network it covers, so a receipt chain here becomes comparable with a transaction on a chain that executes in one step.
Full historical coverage is available today as a data-share or a file delivery. Real-time delivery is enabled on request. Point-in-time balance tables can be enabled for NEAR on request.
How SonarX indexes NEAR
Following an action to its conclusion is the work here. Because receipts spawn receipts, the effects of one call can land several blocks later on a different shard, so SonarX resolves the whole tree rather than stopping at the transaction that started it. Shards are the second consideration: a block carries one chunk per shard, a shard can miss its chunk, and the layout has changed over the chain’s life, so continuity is tracked per shard rather than assumed from block height. Identity is the third, since named accounts with subaccounts and multiple access keys make one owner a tree, and storage staking means a reported balance is not all spendable.
What teams build with NEAR data
Fund accounting is the first workload and the one the receipt model reshapes, because a movement of value is the outcome of a receipt chain rather than a line in a transaction, and a ledger built from transactions alone will not balance. Identity mapping is the second: custody teams need the subaccounts and access keys under one owner grouped together, which is what wallet analytics does across chains. Reward accounting for delegation is the third, derived from staking state per epoch. Token flow analysis is a fourth, and it depends on reading contract logs, since fungible tokens here report transfers as structured log entries rather than as indexed event topics. Teams comparing throughput designs pull Solana into the same warehouse, sometimes with Aptos beside it.
Getting NEAR data from SonarX
Tell us the delivery target, how far back you need and how fresh it has to be, and the share is scoped against that. NEAR history is available now as a share or a file delivery, and streaming is provisioned on request. Say whether you need receipt-level detail or account-level positions, because the first is a much wider backfill. The published coverage matrix for every network SonarX indexes lives in the data documentation, and the rest of the catalogue is at all indexed chains.
Is there a NEAR data API?
APIs over indexed NEAR data are enabled on request: the same indexed dataset the Snowflake share reads, served over REST once provisioned. Tell us the lookup pattern you need.
How do I get NEAR data into Snowflake?
SonarX provisions a data-share into your own Snowflake account. The share appears as a database you query with SQL, so there is no pipeline to build and no second copy to store, and it stays current as SonarX advances the indexing pipeline.
How far back does NEAR coverage go?
The historical data-share and file delivery cover the chain's recorded history from its 2020 launch forward, and are available today. The shard layout has changed over that period, so per-shard continuity is part of what gets checked when a backfill is scoped, and depth is confirmed then.
How does SonarX handle NEAR receipts?
By following them to the end. A signed transaction is converted into a receipt, and a receipt that calls another contract produces further receipts that execute in later blocks and possibly on another shard. The effects of one user action are therefore a tree rather than a row, and a view built only on transaction hashes will miss most of what happened.
Are NEAR account names the same as addresses?
They are the account identifier, and they behave differently from a hash. An account is a readable name that can own subaccounts beneath it, and each account can carry several access keys, including keys limited to calling one method on one contract. Attribution therefore works on a hierarchy and a permission set rather than on a single opaque string.
Is NEAR EVM-compatible?
Not natively. Contracts here compile to WebAssembly, so Solidity bytecode does not deploy to the protocol itself. EVM compatibility on this network comes from Aurora, an EVM implemented as a contract on NEAR, which means its transactions are wrapped inside NEAR receipts rather than recorded as native EVM blocks.