Free tools Windows power users keep installed
One-click scans. No signup required.
For a production NEAR application in 2026, do not make the old near.org or pagoda.co free RPC URLs your reliability plan. Those services entered phased deprecation in 2025 and now carry tight rate limits. Use a managed endpoint such as FastNear or QuickNode when you want fast deployment and someone else to operate the node; run your own node when you need infrastructure control, custom traffic policy, or an archival data pipeline.
The right endpoint depends on four things: request volume and availability expectations, whether you need historical state, where you want traffic routed, and how much node operations your team can own. The comparison below separates regular from archival access and explains the operational consequences of each choice.
As an Amazon Associate I earn from qualifying purchases.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallWhat an NEAR RPC endpoint does
An NEAR RPC endpoint is the HTTP or WebSocket interface through which an application reads chain data and submits transactions. Wallets, dashboards, indexers, bots, back ends and developer tools call JSON-RPC methods to query account state, inspect blocks and chunks, obtain validator information, look up receipts, and broadcast signed transactions. The endpoint may be operated by a public service, a commercial infrastructure provider, or your own node.
RPC is not the same thing as an indexer or a complete historical database. A regular node can answer current-state and recent-chain questions while retaining only a limited window of history. If your application must reconstruct old contract state, inspect receipts from far back in the chain, or replay blocks, you need an archival endpoint or an archival node and any indexing pipeline that sits on top of it.
#1 Best Overall
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (8GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- Mega Heat Sink - Black Anodized
Public NEAR RPC endpoints: status and limitations
The NEAR Infrastructure Committee announced a phased deprecation of the free RPC services under near.org and pagoda.co beginning June 1, 2025. The final phase, beginning August 1, 2025, reduced regular mainnet and testnet limits to 30 requests per minute and 75 requests per 10 minutes, with still lower limits for archival traffic. The committee described the services as “fully deprecated” and said they would remain only to avoid breaking legacy users.
That means a legacy URL may still answer a request, but a successful response today is not a production guarantee. The documented limits are too restrictive for many public applications, and the service can change as the deprecation proceeds. The committee recommended moving to FastNear or Lava Network, selecting a paid provider tier, or operating a dedicated node for higher-volume workloads.
When a public endpoint is still useful
- Short-lived experiments and tutorials where occasional throttling is acceptable.
- Local development that does not expose the endpoint as a dependency for users.
- A temporary migration bridge while you deploy a provider or your own node.
Why it is a poor production default
- Rate limits are explicitly low and archival limits are lower still.
- There is no operational control over capacity, routing, maintenance or incident response.
- Deprecation creates uncertainty for new systems and makes capacity planning difficult.
If you must keep a legacy URL during migration, put it behind a configurable endpoint setting, add retries with backoff, monitor HTTP and JSON-RPC errors, and have a second endpoint ready. Do not hard-code it into clients that cannot be updated quickly.
Managed NEAR RPC providers
A managed provider runs the node fleet, exposes an authenticated URL, and handles much of the scaling and maintenance. You still need to design retries, key management, request budgets and failover, but you avoid synchronizing a node and maintaining its storage.
Rank #2
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (4GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- CanaKit Mega Heat Sink - Black Anodized
FastNear
FastNear publishes separate regular and archival base URLs:
| Network and data set | Endpoint | Typical use |
|---|---|---|
| Mainnet regular | https://rpc.mainnet.fastnear.com | Current application traffic and recent epochs |
| Testnet regular | https://rpc.testnet.fastnear.com | Testing against recent testnet data |
| Mainnet archival | https://archival-rpc.mainnet.fastnear.com | Older blocks, receipts and historical contract state |
| Testnet archival | https://archival-rpc.testnet.fastnear.com | Historical testnet queries |
FastNear’s regular service is intended for recent epochs and is the default for most application requests. Its archival service is a distinct endpoint for older blocks, receipts and historical state. The documentation covers state queries, block and chunk inspection, transaction submission, validator data and protocol introspection.
Authentication can use an API key in an Authorization: Bearer ... header or an apiKey query parameter. Prefer the header so secrets do not appear in browser history, proxy logs or copied URLs. Store the key in a server-side secret manager, restrict who can rotate it, and issue separate keys for development and production.
QuickNode
QuickNode provides managed NEAR endpoints for mainnet and testnet over HTTP and WSS. Its documentation lists archive availability and no pruning for both networks. The setup is dashboard-led:
Rank #3
- CanaKit Raspberry Pi 5 Essentials Starter Kit
- Create an account and open the endpoint creation flow.
- Choose NEAR as the chain and select mainnet or testnet.
- Create the endpoint and copy the generated provider URL.
- Send a JSON-RPC request such as
statusto verify connectivity.
The service uses native NEAR JSON-RPC methods, so an application using near-api-js can keep its existing method calls rather than adopting a provider-specific API. This is useful when a team already has a multi-chain provider workflow or wants a graphical place to manage endpoints. Confirm the selected plan’s request limits, archive coverage, pricing and SLA before committing; those commercial terms can change.
Ankr as another hosted option
Ankr’s current NEAR product information says that public and freemium access has been deprecated and that NEAR access requires a paid Premium plan and API key. It advertises higher throughput and rate limits, archive and trace methods, analytics, support and enterprise options. Treat all of those plan details as vendor information that must be checked at purchase time, not as a permanent network property.
Self-hosting a NEAR node
Self-hosting gives you control over placement, routing, access policy, capacity and retention. It also transfers every operational responsibility to your organization. The official NEAR Lake guide describes a self-hosted binary that runs as a regular NEAR peer-to-peer node, synchronizes chain data and writes indexed block data to Amazon S3 or compatible object storage.
What the setup involves
- Compile or obtain the NEAR Lake software according to the version documented by NEAR.
- Generate the chain configuration and genesis files for the network you will join.
- Provision suitable compute, fast local storage, network bandwidth and object storage for indexed data.
- Start synchronization. For a non-local network, the node must catch up before it can serve the history your application expects.
- Configure the Lake process to write indexed blocks to S3-compatible storage, then expose only the RPC interface your clients require.
- Add monitoring for synchronization height, peer health, disk use, object-storage writes, RPC latency and error rates.
NEAR recommends Epoch Sync as the lighter synchronization approach. A normal, non-archival node retains only the last five epochs. To retain the full chain history, set "archive": true in config.json. Archival synchronization can take a long time; the documentation discusses using backups to reduce catch-up time.
Rank #4
- Includes Raspberry Pi 5 16GB with 2.4Ghz 64-bit quad-core CPU (16GB RAM)
- Includes 128GB Micro SD Card pre-loaded with 64-bit Raspberry Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit Low Noise Bearing System Fan
- Mega Heat Sink - Black Anodized
Operational duties you cannot outsource to a provider
- Keeping the node software and protocol configuration current during upgrades.
- Protecting the host and RPC perimeter with firewall rules, authentication and patching.
- Expanding disks and bandwidth before retention or traffic reaches a hard limit.
- Maintaining backups and a recovery procedure for configuration, keys and indexed data.
- Staffing alerts and incident response when synchronization stalls or peers disappear.
A self-hosted node is not automatically an archival indexer. Decide separately how long to retain raw chain data, where to store it, and which indexes your application needs for efficient historical queries.
Regular versus archival RPC
Choose regular RPC when your application reads current balances, recent receipts, live validator data, recent blocks or submits transactions. Choose archival RPC when the request targets blocks, receipts or contract state outside the regular retention window, or when an audit and analytics workflow must reproduce old chain state.
| Requirement | Regular endpoint | Archival endpoint or node |
|---|---|---|
| Current account and contract queries | Appropriate | Also works, usually with higher historical coverage |
| Recent transaction submission | Appropriate | Usually unnecessary |
| Old blocks and receipts | May be unavailable after pruning | Required |
| Historical contract state | Limited to retained epochs | Required |
| Storage and synchronization effort | Lower | Higher; full retention takes longer to synchronize |
Do not send every request to an archival endpoint by default. Route normal traffic to regular RPC and reserve archival capacity for jobs that need it. This reduces cost and keeps expensive historical queries from competing with user-facing requests.
Comparison by the decisions that affect reliability
| Option | Availability and limits | Latency and routing | History | Operational burden | Cost information |
|---|---|---|---|---|---|
| Legacy public near.org or pagoda.co | Deprecated; 30 requests/minute and 75 requests/10 minutes for regular mainnet and testnet in the final 2025 phase; archival limits lower | Service-controlled | Limited and more restricted for archival use | Low setup effort, high dependency risk | Public pricing and SLA not stated |
| FastNear | Managed capacity; API-key access | Provider-operated | Separate regular and archival URLs | Low node-operations burden | Plan pricing and SLA not stated |
| QuickNode | Managed mainnet and testnet endpoints; HTTP and WSS | Provider dashboard and distributed-routing claims | Archive availability and no pruning listed | Low node-operations burden | Verify plan limits, pricing and SLA |
| Ankr Premium | Paid API key; advertised higher throughput | Provider-operated | Archive and trace methods advertised | Low node-operations burden | Verify current plan terms |
| Self-hosted node | Your team sets capacity and availability | You choose placement and network path | Five-epoch non-archival retention; full history with "archive": true |
Synchronization, storage, upgrades, backups and on-call are yours | Compute, storage, bandwidth and staffing recur; exact totals depend on deployment |
How to choose an endpoint for your workload
Low-volume development
Use a testnet regular endpoint and keep the URL configurable. A public endpoint can be acceptable for a tutorial or an experiment, but design the client so changing providers requires an environment-variable update rather than a code release. Avoid running production user traffic through a free legacy service.
Best Value
- Includes Raspberry Pi 5 with 2.4Ghz 64-bit quad-core CPU (8GB RAM)
- Includes 32GB EVO+ Micro SD Card pre-loaded with 64-bit Pi OS, USB MicroSD Card Reader
- CanaKit Turbine Black Case for the Raspberry Pi 5
- CanaKit 45W PD Power Supply for the Raspberry Pi 5
- Display Cable - 6 foot (Supports up to 4K 60p)
Managed production traffic
Choose FastNear if a NEAR-specific service with explicitly separated regular and archival URLs fits your architecture. Choose QuickNode if dashboard management, HTTP and WSS options, or an existing multi-chain workflow matter more. For either provider, load-test within the purchased plan, set request timeouts, retry only idempotent reads, and monitor rate-limit responses.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Archive-heavy analytics or regulated retention
Use an archival provider endpoint for a fast start, or self-host an archival node when retention, placement and access policy are core requirements. An archival node is justified when you need predictable internal traffic, a custom indexing pipeline, or independence from a provider’s retention policy. Budget for the longer initial synchronization and ongoing storage growth.
Infrastructure-control requirements
Self-host when your security or networking policy requires private routing, a controlled perimeter, dedicated capacity or an internally governed data path. A provider is usually simpler when your team does not already operate distributed systems and the application can tolerate a vendor dependency.
Production hardening checklist
- Keep mainnet, testnet, regular and archival URLs in separate configuration values.
- Never expose provider API keys in browser JavaScript, mobile binaries or public repositories.
- Implement exponential backoff and jitter for transient failures; do not retry a rejected transaction blindly.
- Track latency, error codes, HTTP status, rate-limit responses and synchronization lag.
- Use a second provider or a self-hosted fallback for critical read paths, and test failover rather than merely documenting it.
- Cache immutable block and chunk responses where appropriate, while treating account and contract state as time-sensitive.
- Set alerts before storage, bandwidth or request quotas are exhausted.
- For archival jobs, schedule heavy scans away from interactive traffic and persist checkpoints so a failed run can resume.
- Review provider limits, archive behavior, pricing and SLA whenever your traffic profile or chain protocol version changes.
Common failure modes and fixes
Requests begin returning rate-limit errors
Confirm which endpoint is being used and whether the request is regular or archival. The old public services have documented tight limits, so migrate rather than trying to outsmart the throttle. On a managed plan, inspect usage and raise the tier or distribute traffic only within the provider’s terms.
A historical query returns missing data
Check whether the request targets a block or state older than the regular retention window. Retry against the provider’s archival URL or an archival self-hosted node. If the query is part of a recurring report, record the exact block height and preserve your own derived data.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →A self-hosted node is not ready after startup
Synchronization is required on non-local networks. Check peer connectivity, disk capacity, bandwidth, configuration and current sync height. Epoch Sync is the recommended lighter approach; archival mode naturally takes longer and may require restoring a backup to shorten catch-up.
Clients fail after switching providers
Use native NEAR JSON-RPC methods and compare the raw request and response before changing application logic. QuickNode states that near-api-js applications can use its endpoint without rewriting existing calls. Differences that remain are more likely to involve authentication, URL construction, network selection or plan limits than the JSON-RPC method itself.
Quick Recap
A practical migration path from a legacy public URL
- Inventory every service, script and client that calls the old near.org or pagoda.co endpoint.
- Classify each call as testnet or mainnet, regular or archival, read or transaction submission.
- Provision a managed endpoint or synchronize a node, then run the same JSON-RPC checks against it.
- Move the URL and credentials into deployment configuration, not source code.
- Test throttling, provider failure, archival queries and transaction retries in a staging environment.
- Switch production traffic gradually while watching latency, errors, synchronization and quota usage.
- Retire the legacy endpoint after logs show no remaining callers.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
