What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
For a production NEAR application in 2026, do not make the old near.org or pagoda.co free RPC services your primary dependency. Their phased deprecation left them with tight documented limits and legacy-only status. A managed endpoint such as FastNear or QuickNode is the practical default when you need rapid deployment and someone else to operate the node. Run your own NEAR node when you need control over routing and access, predictable internal traffic, or an archival and indexing pipeline that a hosted plan cannot provide.
The right endpoint depends on four questions: how much traffic you send, whether you need historical state, how much operational work your team can own, and what security and availability controls your application requires.
As an Amazon Associate I earn from qualifying purchases.
Which NEAR RPC endpoint should you use?
Use this workload-based rule:
| Workload | Best starting point | Reason |
|---|---|---|
| Local development, demos, or a low-volume script | A managed regular endpoint | You avoid depending on deprecated public infrastructure while keeping setup simple. |
| Production application with variable traffic | FastNear or QuickNode managed RPC | Capacity, endpoint operations, and scaling are handled by the provider; you can add authentication and monitor usage. |
| Queries for old blocks, receipts, or historical contract state | An archival provider endpoint or your own archival node | Regular nodes retain only recent history; archive access is a separate capability. |
| Strict routing, private network policy, custom indexing, or internal high-volume traffic | Self-hosted NEAR node (possibly archival) | Your team controls placement, traffic policy, retention, and the indexing pipeline. |
Do not choose solely on advertised request-per-second figures. A suitable endpoint must also expose the JSON-RPC methods your application calls, retain the history you query, authenticate requests safely, and provide an operational model your team can support.
What happened to NEAR’s public RPC endpoints?
NEAR’s Infrastructure Committee announced a phased deprecation of the free RPC services under near.org and pagoda.co beginning June 1, 2025. The final phase began August 1, 2025: regular mainnet and testnet traffic was limited to 30 requests per minute and 75 requests per 10 minutes, with lower limits for archival access. The committee described the endpoints as remaining only to avoid breaking legacy users and as “fully deprecated.”
#1 Best Overall
The committee’s stated rationale was that a fully subsidized service was discouraging decentralization and making it harder for commercial RPC operators to compete. Its migration guidance pointed users toward FastNear, Lava Network, a paid provider tier, or a dedicated node. Those statements come from the Infrastructure Committee announcement dated May 19, 2025; endpoint behavior can change, so check the current response and limits before relying on any public URL.
A public URL that still answers a test request is not evidence of production suitability. Deprecation means there is no dependable capacity or support expectation for a new high-volume system. Treat these endpoints as a temporary compatibility path while you migrate, not as your reliability plan.
Managed NEAR RPC providers
FastNear: NEAR-specific regular and archival URLs
FastNear publishes separate base URLs for recent-state and archival traffic:
| Network | Regular RPC | Archival RPC |
|---|---|---|
| Mainnet | https://rpc.mainnet.fastnear.com | https://archival-rpc.mainnet.fastnear.com |
| Testnet | https://rpc.testnet.fastnear.com | https://archival-rpc.testnet.fastnear.com |
FastNear’s regular service is intended for recent epochs and ordinary application calls. Its archival service exposes older blocks, receipts, and historical contract state. The documented API covers state queries, block and chunk inspection, transaction submission, validator data, and protocol introspection. Authentication can use an Authorization: Bearer … header or an apiKey query parameter.
That split is useful operationally: send normal reads and writes to the regular URL, and route explicitly historical jobs to the archival URL. Keeping the two paths separate prevents an indexer or analytics task from consuming the capacity your user-facing application needs.
QuickNode: dashboard-led setup with HTTP and WSS
QuickNode documents managed NEAR endpoints for both mainnet and testnet. Its product documentation lists HTTP and WebSocket Secure (WSS) access, archive availability, and no pruning for both networks. The setup flow is:
Recommended Free Tools
- Create an account and open the endpoint creation screen.
- Select NEAR as the chain and choose mainnet or testnet.
- Create the endpoint, then copy the provider URL shown in the dashboard.
- Send a JSON-RPC request such as
statusto verify connectivity before changing application configuration.
QuickNode states that its endpoint uses native NEAR JSON-RPC methods and works with near-api-js without rewriting existing application code. This is useful if your team already uses a multi-chain provider dashboard or needs both HTTP polling and WSS connections. Confirm the selected plan’s traffic limits, archive terms, pricing, and service-level commitments at purchase time; those commercial details are plan-specific and can change.
Ankr: paid access only according to its current product page
Ankr’s NEAR RPC page says its public and freemium access has been deprecated. It describes NEAR access as a Premium-plan service requiring a paid API key, with higher throughput and rate limits, archive and trace methods, analytics, support, and enterprise options. Treat those statements as vendor-plan information: verify the current entitlement, limits, and price when you buy rather than designing around an older page.
When self-hosting a NEAR node makes sense
Self-hosting moves responsibility from a provider to your organization. The 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.
Free tools Windows power users keep installed
One-click scans. No signup required.
What your team must operate
- Node compilation and installation, including the correct chain configuration and genesis files.
- Initial synchronization and ongoing peer-to-peer connectivity.
- Fast local storage, compute, bandwidth, and object-storage capacity for indexed data.
- Monitoring for sync lag, disk pressure, process health, and RPC errors.
- Software upgrades, configuration changes, backups, incident response, and on-call coverage.
- Network perimeter controls and an authentication strategy for applications that call the node.
For non-local networks, synchronization is required. NEAR recommends Epoch Sync as the lighter approach for getting a node current. A normal node is non-archival and retains only the last five epochs. To retain full history, set "archive": true in config.json before archival synchronization.
Self-hosting sequence
- Choose mainnet or testnet and size compute, storage, and network capacity for that chain.
- Compile or install the NEAR Lake software and generate the chain configuration and genesis files described in the official guide.
- Start synchronization with Epoch Sync where appropriate; do not expose an RPC interface to the internet until access controls and monitoring are in place.
- Enable archival mode in
config.jsononly if your workload requires complete historical retention. - Configure the Lake indexer to write block data to S3 or compatible object storage, then verify that new objects arrive continuously.
- Measure sync lag and RPC latency under representative application traffic before cutting over.
- Document upgrade, backup, restore, and failover procedures and assign ownership for them.
Archival synchronization can take a long time. The guide discusses using backups to reduce catch-up time; include restore testing in your operating plan rather than assuming a copied disk is a usable recovery.
Regular versus archival RPC
“Archive” describes retained history, not a faster version of ordinary RPC. A regular endpoint is optimized for current application state and recent epochs. An archival endpoint or archival node is required when a method needs old blocks, receipts, or historical contract state that has been pruned from a regular node.
Best Value
| Question | Regular endpoint | Archival endpoint or node |
|---|---|---|
| Wallet balances and current contract state? | Usually appropriate | Usually unnecessary |
| Submitting transactions? | Appropriate, subject to provider policy | Often unnecessary for submission itself |
| Indexing old blocks and receipts? | May fail once data is outside retained epochs | Required capability |
| Historical state at a past block? | Use only if that block remains retained | Designed for this query |
| Storage and synchronization burden? | Lower for hosted users and non-archival nodes | Higher; archival self-hosting needs explicit configuration and longer sync |
Separate archival workloads from latency-sensitive reads where possible. A backfill job can issue thousands of historical requests and create avoidable contention if it shares the same endpoint and credentials as the public API.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Provider, public, and self-hosted options compared
| Decision axis | Legacy public service | Managed provider | Self-hosted node |
|---|---|---|---|
| Availability responsibility | Unreliable for new production systems because the service is deprecated and rate-limited | Provider operates capacity; review its limits and SLA | Your team owns uptime, redundancy, and incident response |
| Latency and routing | Little control | Some providers advertise distributed routing | You choose placement and network path, but must engineer capacity |
| History | Archival limits are especially restrictive | Select regular or archive products | Choose non-archival retention or enable archive mode |
| Security | Limited control over access policy | Protect API keys and configure application access controls | Protect the node perimeter, credentials, software, and monitoring stack |
| Operational effort | Low until an outage or limit blocks you | Low node-operations burden | High: synchronization, storage, upgrades, backups, and on-call |
| Cost model | No dependable production cost or commitment | Usage tiers and possible archive surcharges | Recurring compute, storage, bandwidth, and staffing |
Migration plan from a legacy public URL
- Inventory calls. List every JSON-RPC method, network, request rate, burst pattern, WebSocket use, and historical query in your application and background jobs.
- Classify history needs. Mark calls that require old blocks, receipts, or past contract state; those must target archival capacity.
- Select a target. Choose a managed regular endpoint for ordinary production traffic, add an archival endpoint for historical work, or design a self-hosted deployment if control requirements justify the operating cost.
- Externalize configuration. Store the endpoint URL and API key in deployment secrets or environment configuration, not source code, logs, or client-side bundles.
- Test method compatibility. Run representative requests on testnet and mainnet read-only paths, including error handling for rate limits, timeouts, and pruned history.
- Load-test responsibly. Reproduce normal bursts within the selected plan’s limits and verify that archival jobs do not starve user-facing calls.
- Cut over with observability. Record latency, error rate, response height, sync lag where available, and provider quota usage. Keep the old URL only as a short-lived migration reference, never as an untested failover assumption.
Security and reliability checklist
- Keep provider API keys server-side; rotate them and restrict which services can use them.
- Use separate credentials or projects for development, production, and archival batch jobs.
- Apply request timeouts, bounded retries, and exponential backoff so an outage does not create a retry storm.
- Cache safe, repeated reads and batch historical work where the provider’s method and limits allow it.
- Monitor both transport errors and chain freshness. A successful HTTP response from a lagging node can still produce stale application behavior.
- For self-hosting, alert on disk exhaustion, process restarts, peer connectivity, synchronization lag, and failed object-storage writes.
- Document which methods require archive data and test those methods after every provider or node upgrade.
How to budget the choice
There is no single break-even number published for these options. Compare a provider’s usage tier, archive surcharge, overage policy, support, and SLA with the recurring cost of self-hosted compute, fast storage, bandwidth, object storage, backups, monitoring, and staff time. Include the cost of a second region or standby node if your availability target requires one. A low invoice for a single self-hosted machine is not the full operating cost when synchronization failures and upgrades need human attention.
For a small team, managed RPC usually wins because it converts node operations into a metered service. Self-hosting becomes easier to justify when traffic is predictable and large, data-retention requirements are strict, network placement is sensitive, or your organization already operates blockchain infrastructure and an on-call rotation.
Quick Recap
Practical decision checklist
- Choose a managed regular endpoint if you need to ship quickly and your calls concern current state.
- Add managed archival access when an indexer, audit tool, or analytics job reads historical blocks or state.
- Choose self-hosting when control over routing, retention, access policy, or internal traffic outweighs the operational burden.
- Use the deprecated public services only while removing legacy dependencies; do not build a new production SLA around them.
- Re-check provider limits, archive availability, pricing, and SLA at the time of purchase because those terms are volatile.
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.
