// NEAR

The Stack NEAR Builders Ship On

Connect to NEAR Mainnet and Testnet with low-latency RPC, full archive data, debug and trace APIs, and real-time Streams. The complete NEAR data stack, managed from a single Quicknode dashboard.

// Supported networksMainnetTestnet
// 99.99% uptime SLA17+ global regions
// Unified NEAR Stack

Mainnet, Testnet, and Archive
in One Dashboard.

NEAR builders need more than basic RPC. Quicknode runs the full surface: low-latency NEAR JSON-RPC over HTTPS and WSS, plus full archival history, all from one dashboard.

InterfaceStatus
MAINNETONLINE
TESTNETONLINE
ARCHIVEONLINE
GLOBALONLINE
// Read & Stream

Data Access for Every NEAR Workload

Query, subscribe, and stream NEAR data with low latency. From a single view call to full historical blocks and chunks, you get the right interface for the job.

NEAR JSON-RPC over HTTPS and WSS on Mainnet and Testnet
View methods, account state, blocks, chunks, and transaction status
Archival access to full NEAR history with no pruning
Streams for backfill and real-time NEAR blocks and receipts
Webhooks for push notifications on accounts and events
// Build & Ship

Native SDK Support

Land transactions on the same Quicknode account. The NEAR toolchain you already know works unchanged.

near-api-js and the modular @near-js packages supported out of the box
Token authentication, rate-limiting, JWT, and whitelisting on every endpoint
Full query, block, chunk, gas price, and tx method coverage
Send signed transactions through low-latency, geo-routed endpoints

Enterprise-grade security and compliance built in

SOC 1
SOC 2 Type II
ISO 27001
// Every NEAR Data Pattern

The Full Data Suite.
Every NEAR Data Pattern.

Read, query, and replay NEAR data from one account. Pick the method, ship faster.

NEAR JSON-RPC

The full NEAR JSON-RPC over HTTPS and WSS on Mainnet and Testnet. Query accounts and view methods, read blocks and chunks, check transaction status, and broadcast signed transactions, with predictable rate limits.

Archive Access

Full historical NEAR state with no pruning. Read any block, chunk, or account state from genesis for indexing, analytics, and reconciliation.

Query & View Methods

Use the query request to read account state, contract code, and access keys, and call view functions with view_account, view_state, view_access_key, and call_function at any block height or finality.

Blocks, Chunks & Receipts

Fetch blocks and chunks by height, hash, or finality, and resolve receipts with EXPERIMENTAL_receipt. Walk the chain deterministically for indexers, explorers, and analytics.

Transaction Status & Broadcast

Broadcast signed transactions with send_tx, then track execution using tx and EXPERIMENTAL_tx_status, including receipts and gas outcomes, across Mainnet and Testnet.

Gas, Protocol & Validators

Read gas_price, pull the live EXPERIMENTAL_protocol_config, and list current validators to price transactions and monitor network health in real time.

// Developer Experience

Native NEAR RPC,
no rewrites.

Point near-api-js at a Quicknode NEAR endpoint and query accounts, call view methods, and send transactions. The same NEAR JSON-RPC you already use, on private low-latency infrastructure.

No rewrites

Point your existing NEAR codebase at a Quicknode endpoint and deploy. near-api-js, the NEAR CLI, and your contracts carry over unchanged.


Same NEAR JSON-RPC methods

query, block, chunk, tx, and the EXPERIMENTAL_ methods all behave exactly as they do against a self-hosted NEAR node.

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
// Native NEAR RPC via near-api-js
import { JsonRpcProvider } from "@near-js/providers";
const provider = new JsonRpcProvider({
url: QUICKNODE_NEAR_URL
});
// Query an account's current state
const account = await provider.query({
request_type: "view_account",
finality: "final",
account_id: "example.near"
});
console.log(account.amount);
// Resources

Build on NEAR quicker.

Docs, guides, and runnable sample apps for every NEAR workload. Clone, customize, and ship.

// Docs

NEAR Documentation

Full reference for every NEAR JSON-RPC method, covering accounts, access keys, contracts, blocks, chunks, and transactions. Code examples in cURL, JavaScript, Python, and Ruby.

// guide

Set Up a NEAR Project from Scratch

Install dependencies, configure your NEAR endpoint, and ship your first onchain interaction with JSON-RPC.

// Sample Apps

Sample App Library

Runnable sample apps and starter kits across Quicknode-supported chains, including NEAR. Clone one and ship.

// Let's Build

Start where you are.

From your first NEAR endpoint to mission-critical production workloads, Quicknode scales with you. Get started in minutes.

// Developers

For builders who move fast.

Spin up your NEAR endpoint and ship. The free tier covers prototyping and small production loads, no credit card required.

Start building for free
// Enterprise

For teams scaling with confidence.

Dedicated NEAR infrastructure, contractual SLAs, priority support, and procurement-ready terms for wallets, exchanges, trading firms, and high-volume protocols.

Contact sales
"With Quicknode, we can immediately pull a supported chain, pass the endpoint to the client, and know it'll just work. No need for trial runs or manual validation. Archival data, low latency, and consistent uptime are built in, enabling us to meet tight integration windows and confidently support emerging networks without operational overhead."
Victor Fei, Founder & CEO @ Ormi
// FAQ

Frequently Asked Questions

Still have unanswered questions? Reach out to support and the Quicknode team can help you find answers.