FastNear RPC / APIs

FastNear ships multiple docs surfaces because builders need different tradeoffs. Start from the job you need done, then drop into the detailed reference from there.

Canonical JSON-RPCRPCUse canonical JSON-RPC methods for protocol-native reads, transaction submission, and protocol inspection.Best for:

• account state
• block lookups
• contract view calls
• validator data

Indexed balancesFastNear APIStart here when you want wallet-friendly balances, NFTs, staking, or public-key lookups without raw JSON-RPC envelopes.Best for:

• full account state
• fungible token balances
• NFT holdings
• public key lookups

Tx historyTransactions APIQuery transaction history by account, receipt, block, or hash when you need a builder-facing history API instead of node polling.Best for:

• account activity
• transaction lookups
• receipt tracing
• block transaction history

SnapshotsSnapshotsUse curated snapshot flows when you need to stand up RPC or archival infrastructure without replaying the chain from scratch.Best for:

• mainnet snapshots
• testnet snapshots
• snapshot workflow overview

Higher limitsAuth & AccessSee how FastNear API keys fit into the docs UI, and how to move from demo flows to secure backend usage.Best for:

• auth overview
• browser demo auth
• production backend auth

RealtimeNEAR Data APIUse NEAR Data when you need optimistic or recently finalized block-family reads without presenting it as a streaming product.Best for:

• optimistic block reads
• latest finalized block
• block header polling

Before you integrate

These are the operational details technical teams usually want up front:

• Auth & Access: understand the difference between the in-docs demo flow and backend production auth.
• Dashboard: manage API keys and move to higher-limit usage patterns.
• Status: check incidents or degraded service before debugging application behavior.
• RPC Reference: choose regular versus archival RPC depending on how much chain history you need.
• Snapshots: bootstrap infra faster when you are standing up RPC or archival nodes.

Practical routing guidance

• Start with RPC Reference when you need canonical JSON-RPC requests, transaction submission, or protocol-native responses.
• Start with FastNear API when you are building wallet, explorer, or portfolio features and want indexed account views.
• Start with Transactions API when you care about account-scoped activity, receipts, and execution history.
• Start with NEAR Data API when you are polling recent block-family data and do not need to present it as streaming infrastructure.

Other API families

These complementary APIs stay useful once you know the core surfaces above:

• FastNear API: Indexed account views for balances, NFTs, staking, and public-key lookups.
• Transactions API: Account, block, receipt, and transaction history from indexed execution data.
• Transfers API: Purpose-built transfer history for account activity and pagination-heavy UIs.
• KV FastData API: Indexed key-value history and latest-state lookups for contract storage analysis.
• NEAR Data API: Recent finalized and optimistic block-family reads for low-latency polling workflows.

If you are building for AI or agents

• Start with Choosing the Right Surface to map the job to the right FastNear surface.
• Use Auth for Agents when the caller is an automation, worker, or agent runtime.
• Borrow from Agent Playbooks when you want a concrete workflow pattern.
• Use Auth & Access to keep agent credentials on the server side.
• Use page-level Copy as Markdown actions to move clean docs context into prompts, notes, and agent runtimes.