Bright technical workstation with light surfaces, a small plant, and calm indexer dashboards.
Protocols

RPC Endpoint Deprecation and Migration Guide

Changelog for JSON-RPC API methods being deprecated, modified, or replaced across nearcore releases. Exchanges, data indexers, and application backends rely on this to update services and avoid broken integrations.
introduction
RPC ENDPOINT LIFECYCLE MANAGEMENT

Introduction

A technical changelog for JSON-RPC API methods being deprecated, modified, or replaced across nearcore releases, with operational guidance for teams that depend on specific endpoints.

The NEAR Protocol's JSON-RPC API is the primary interface for exchanges, data indexers, wallets, and application backends to query chain state, submit transactions, and monitor network activity. As the protocol evolves through Nightshade sharding, stateless validation, and congestion improvements, the underlying data models and query patterns change. This forces the deprecation, modification, or replacement of specific RPC methods. Teams that do not track these changes risk broken integrations, stuck withdrawals, or corrupted data pipelines when a deprecated endpoint is removed or begins returning unexpected results.

RPC endpoint deprecations on NEAR are tied to specific nearcore client releases and protocol version bumps. A method may be marked as deprecated in one release, begin returning warnings or degraded data in the next, and be fully removed in a subsequent mandatory upgrade. The EXPERIMENTAL_ prefix on methods like EXPERIMENTAL_tx_status signals that the interface is unstable and subject to breaking changes without a standard deprecation cycle. Operators and builders must correlate the RPC methods their systems call with the rpc_changes sections of nearcore release notes to build a migration timeline before a breaking change reaches mainnet.

For exchanges and custodians, the highest-risk endpoints are those involved in the deposit and withdrawal lifecycle: query, broadcast_tx_commit, tx, and EXPERIMENTAL_tx_status. A change to the finality parameter or the structure of the status response can break balance reconciliation. For indexers and data platforms, changes to chunk or EXPERIMENTAL_receipt methods can corrupt historical data. Chainscore Labs provides integration impact assessments that map your system's RPC dependency graph against the NEAR deprecation timeline, identifying which services will break, in which release, and what migration work is required to maintain continuity.

RPC ENDPOINT DEPRECATION AND MIGRATION

Quick Facts

A scannable reference of JSON-RPC API methods being deprecated, modified, or replaced across nearcore releases, and the operational impact on dependent services.

AreaWhat changesWho is affectedAction

Deprecated Methods

Specific RPC methods are marked for removal in a future release, returning warnings or errors.

Exchanges, data indexers, wallet backends, DeFi protocols

Audit codebase for deprecated method calls and plan migration to replacements.

Method Signature Changes

Request parameters or response schemas for an existing method are modified.

Application backends, block explorers, analytics dashboards

Update parsing logic and integration tests to match the new schema.

Replacement Methods

New RPC methods are introduced to supersede deprecated or less efficient ones.

All RPC consumers

Adopt the new method to ensure long-term compatibility and access to optimized data.

Performance & Rate Limits

Default rate limits or computational costs for specific methods are adjusted.

High-volume RPC users, indexers, trading bots

Re-architect query patterns to batch calls or use alternative endpoints to avoid throttling.

Query Format Changes

Underlying data encoding, such as base58 vs base64 for keys, is standardized.

Wallets, CLI tools, custodians

Update key generation and display logic to handle the new encoding format.

Network Compatibility

A method's behavior diverges between testnet and mainnet during a transition period.

Development teams, QA engineers

Test all RPC interactions against the specific network version to avoid testnet-only assumptions.

Removal of Unstable Endpoints

Endpoints prefixed with 'EXPERIMENTAL_' are removed or changed without notice.

Early adopters, front-end applications

Migrate to stable, NEP-standardized equivalents immediately to prevent breakage.

technical-context
LIFECYCLE AND OPERATIONAL IMPACT

How NEAR RPC Deprecations Work

A structured process governs the deprecation of JSON-RPC methods in nearcore, requiring proactive migration from node operators, exchanges, and indexers to avoid broken integrations.

NEAR Protocol manages RPC endpoint deprecations through a phased lifecycle tied to the nearcore client release cadence. When a method is identified for removal—often due to architectural shifts like the move to stateless validation or the introduction of a more efficient query pattern—it is first flagged as deprecated in a specific client version. During this phase, the method remains functional but generates warnings in node logs, signaling to operators that its support is temporary. This deprecation window, which typically spans multiple protocol versions, is the critical period for downstream teams to update their services.

The final removal occurs in a subsequent nearcore release, often aligned with a protocol version bump that makes the upgrade mandatory for validators. At this point, calls to the deprecated method return an error, which can cause immediate failures in exchange deposit workflows, indexer data pipelines, and application backends. The operational impact is not uniform: a method used by a block explorer for historical data queries may cause a degraded user experience, while a method used by a custodian for balance checks can halt withdrawals. Teams must correlate the nearcore release notes with their own RPC call patterns to assess the blast radius.

Effective migration requires more than a simple endpoint swap; new methods may have different request parameters, pagination models, or response schemas. For example, a deprecated query might be replaced by a more performant method that requires state witnesses or operates under a different access control model. Chainscore Labs provides integration impact assessments for teams dependent on specific RPC methods, mapping their call surfaces against the deprecation schedule to identify breaking changes, estimate migration effort, and prevent service disruptions before a mandatory client upgrade forces the issue.

RPC DEPRECATION IMPACT

Affected Actors

Exchange and Custodian Impact

Exchanges and custodians are the most sensitive to RPC method deprecations. Their deposit and withdrawal pipelines rely on specific endpoints for transaction status, finality tracking, and balance queries.

Critical actions:

  • Audit all NEAR RPC methods used in hot and cold wallet infrastructure.
  • Map each method to its replacement before the deprecation deadline.
  • Test new endpoints against historical transaction patterns to verify equivalent behavior.

A common failure mode is relying on EXPERIMENTAL_tx_status without a migration path to the stable tx endpoint. Teams should also verify that finality handling matches NEAR's consensus guarantees, not Ethereum's probabilistic model.

Chainscore provides integration impact assessments that identify every affected code path and recommend safe migration strategies before mandatory releases break production flows.

implementation-impact
RPC MIGRATION PLANNING

Implementation Impact by Method Category

Breaking RPC changes affect different integration categories in distinct ways. Assess the impact on your specific use case and plan migration work before the deprecation takes effect in a mandatory release.

01

Exchange Deposit and Withdrawal Flows

Exchanges relying on query methods for balance checks, nonce lookups, or access key validation must audit their hot and cold wallet paths. Deprecation of account-view methods can silently break deposit detection or cause withdrawal failures. Teams should implement replacement methods in staging against testnet before the mainnet activation epoch. Chainscore provides integration impact assessments for exchanges to verify all transaction lifecycle methods are migrated and tested.

02

Indexer and Data Pipeline Breakage

Data indexers that use EXPERIMENTAL_tx_status or deprecated block retrieval methods will experience gaps in historical and real-time data. Changes to response schemas can corrupt downstream analytics, tax reporting, and compliance pipelines. Indexer operators must map every deprecated method to its replacement, adjust parsing logic for new field structures, and backfill affected data. Chainscore helps indexer teams audit their RPC dependency surface and validate migration completeness.

03

Application Backend and SDK Compatibility

Application backends using NEAR SDKs may be shielded from raw RPC changes, but only if SDK versions are current. Deprecated methods often have a lagging support window in SDKs before removal. Teams should verify their near-api-js or near-sdk versions against the deprecation timeline and test against a node running the target nearcore release. Direct RPC callers must refactor to replacement methods. Chainscore offers SDK migration reviews for production applications.

04

Wallet Balance and Account Display Failures

Wallets that query account state via deprecated view_account or access_key methods risk showing stale balances, incorrect nonces, or failing to display account activity. This directly impacts user trust and can lead to support incidents. Wallet teams should test their full account display pipeline against a node running the post-deprecation release and verify that all account-model queries resolve correctly. Chainscore provides wallet integration audits focused on RPC dependency health.

05

Monitoring and Alerting False Positives

Infrastructure monitoring that calls deprecated RPC methods for health checks or block production verification will generate false alerts when methods return errors or empty responses. Operators must update Prometheus exporters, custom health scripts, and Grafana datasource queries to use supported methods before the deprecation epoch. Test alerting pipelines against a canary node running the target release. Chainscore can review monitoring configurations to prevent alert fatigue during migration.

06

Multi-Sig and Custodial Contract Interactions

Custodians and multi-sig deployments that use deprecated RPC methods for transaction construction, simulation, or receipt verification risk constructing invalid transactions or failing to detect execution failures. The account model's access key permissions and function-call limits make incorrect nonce or key state queries especially dangerous. Teams should run a full regression suite against a testnet node on the target release. Chainscore provides custodial integration reviews covering the complete transaction lifecycle.

RPC DEPRECATION IMPACT

Risk Matrix

Operational risks introduced by deprecated or modified JSON-RPC methods and the migration actions required for affected teams.

AreaWhat changesWho is affectedAction

Method Removal

A previously stable RPC method is removed in a new nearcore release.

Exchanges, wallets, data indexers, DeFi backends

Identify all call sites, migrate to the replacement method, and test against a synced testnet node before mainnet activation.

Response Format Change

The structure or data types of a method's response are modified.

Application backends, analytics dashboards, block explorers

Audit parsing logic for strict type checks that may break. Update deserialization models and validate against the new schema.

Default Parameter Shift

Default values for optional parameters like block finality or pagination limits change.

High-frequency trading bots, archival query services

Explicitly set all parameters in requests to remove dependency on defaults. Monitor for unexpected result set sizes.

Deprecation Without Removal

A method is flagged as deprecated but still functional, emitting warnings.

All integration maintainers

Treat deprecation as a critical alert. Schedule migration immediately to avoid emergency work when the method is removed in a subsequent release.

Performance Regression

A replacement method has different resource costs, causing timeouts under existing load patterns.

RPC node operators, high-volume API consumers

Benchmark the new method under production-equivalent load. Adjust client-side timeout and retry logic. Scale RPC infrastructure if the new method is more resource-intensive.

Semantic Inconsistency

A new method returns equivalent data but with different finality guarantees or block references.

Arbitrage bots, bridge relayers, settlement systems

Do not assume 1:1 behavioral parity. Verify finality semantics, block height references, and receipt handling against the canonical spec.

Client Version Incompatibility

A method is only available in a specific nearcore version, breaking environments with mixed-version fleets.

Infrastructure teams managing canary and production nodes

Enforce version consistency across the RPC fleet before enabling the new method. Use feature flags or routing rules to isolate traffic during the transition.

RPC ENDPOINT DEPRECATION

Migration Readiness Checklist

A systematic checklist for infrastructure teams to verify readiness before a deprecated RPC method is removed or a breaking change is activated in a mandatory nearcore release. Each item includes the signal to check, why it matters, and the artifact that confirms readiness.

What to check: Audit your application code, configuration files, and monitoring dashboards for every query, tx, EXPERIMENTAL_, and sandbox method call.

Why it matters: Deprecation notices often target methods with low visibility. A method you rely on for balance checks, nonce lookups, or receipt tracing may be scheduled for removal without your team noticing.

Confirmation artifact: A spreadsheet or configuration map listing every RPC method your service calls, tagged with the nearcore version where it was introduced and any deprecation warnings observed in logs.

Chains We Build On

Looking to build on a specific blockchain?

We build smart contracts, DeFi applications, wallets, tokenization platforms, and blockchain infrastructure across the major ecosystems teams choose today. That includes Ethereum, Arbitrum, Optimism, Polygon, Avalanche, Solana, Sui, Aptos, Hedera, Stellar, and NEAR, with support for additional EVM and non-EVM networks based on your product requirements.

EVM ecosystems

  • Ethereum logo
    Ethereum
  • Arbitrum logo
    Arbitrum
  • Optimism logo
    Optimism
  • Polygon logo
    Polygon
  • Avalanche logo
    Avalanche
  • Cronos logo
    Cronos

Non-EVM ecosystems

  • Solana logo
    Solana
  • Sui logo
    Sui
  • Aptos logo
    Aptos
  • Hedera logo
    Hedera
  • Stellar logo
    Stellar
  • NEAR logo
    NEAR

Additional ecosystems

  • Polkadot logo
    Polkadot
  • Cosmos logo
    Cosmos
  • TON logo
    TON
  • Cardano logo
    Cardano
  • Algorand logo
    Algorand
  • Tempo logo
    Tempo

Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.

RPC MIGRATION FAQ

Frequently Asked Questions

Common questions from infrastructure teams, exchanges, and application backends about NEAR RPC endpoint deprecations, migration timelines, and impact on production services.

What to check: Audit your application's RPC call patterns against the official deprecation notices in the latest nearcore release changelog. Look for methods flagged as deprecated, modified, or removed.

Why it matters: Using deprecated methods can cause silent failures, incorrect data parsing, or hard breakage when the method is removed in a future mandatory release. Exchanges and wallets are particularly vulnerable because they often rely on specific transaction status and balance methods.

Confirmation signal: Generate a list of all RPC methods your backend calls. Cross-reference with the rpc_api module changes in the target nearcore version. If any method appears in the deprecated list, you have exposure.

Chainscore can help by running an integration impact assessment that maps your current RPC usage to the latest protocol version and identifies every breaking or behavioral change.

Trusted by Industry Leaders

Delivering blockchain solutions for 5+ years.

We have partnered with 50+ leading DeFi protocols, NFT ecosystems, and fintech innovators to build secure, scalable, and capital-efficient blockchain products.

Selected Partners & Clients

ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
“I've been working with Chainscore Labs for last 3+ years, they've consistently delivered with strong ownership across multiple projects. The team is reliable and detail-oriented.”
L
Lee Erswell
CEO, Telos Foundation
how to get started

How to get started?

If you're looking for blockchain integration, ChainScore Labs has 5+ years of experience helping teams build and integrate exchanges, wallets, smart contracts, tokenization solutions, and protocol-connected products, we can help you choose the right path, integrate securely, and get to production faster. Our team consists of experienced blockchain developers and architects who can help you with your blockchain integration needs.

01

Exploration & Strategy

Define your product goals and choose the right blockchain architecture for your use case.

02

Architecture & Design

Design the smart contracts, tokenomics, and security parameters of your system.

03

Development & Integration

Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.

04

Security & Launch

Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.

Start a build

Need a blockchain engineering team?

Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.