Migrate Sui from JSON-RPC to gRPC and GraphQL

Sui removes JSON-RPC from the full node in v1.82, so no Sui node serves JSON-RPC after the upgrade. On Chainstack, your Sui node serves gRPC, and Sui Mainnet Global Nodes also serve GraphQL, on the same endpoint and auth token. Port each JSON-RPC call to its gRPC or GraphQL equivalent with the method mapping, with no provider switch and no re-sync.

Sui Testnet nodes on Chainstack no longer serve JSON-RPC. Sui Mainnet nodes stop serving it when they upgrade to v1.82, after Sui releases v1.82 for Mainnet.

Sui retires JSON-RPC in stages, per Sui’s migration guide:

Milestone	Date
JSON-RPC disabled on Sui Foundation’s Mainnet full nodes	Week of Jul 27, 2026
Sui stops publishing JSON-RPC snapshots	End of Aug 2026
Implicit fallback to the archival service disconnected	End of Sep 2026
JSON-RPC removed from the full node code in v1.82	Testnet: Oct 15, 2026. Mainnet: with the v1.82 Mainnet release

Sui’s guide gives Mainnet dates only. The Testnet date is when the Testnet network activated the v1.82 protocol.

What is being removed

Sui removes JSON-RPC in two steps. Sui Foundation turned off JSON-RPC on its public endpoints in July 2026. Sui v1.82 then removes the JSON-RPC service from the full node code itself, so a node on v1.82 does not serve JSON-RPC at all. Node operators cannot keep JSON-RPC enabled, because a node on an older version stops when the network activates the v1.82 protocol. gRPC and GraphQL are the interfaces Sui supports going forward. gRPC uses HTTP/2 and Protocol Buffers for binary serialization, which makes payloads smaller and adds server-side streaming — you subscribe to new checkpoints instead of polling for them. On Chainstack, the migration is JSON-RPC → gRPC and GraphQL, and both run on the same node:

Move performance-sensitive and streaming workloads to gRPC — backends, indexers, typed clients, low-latency lookups, transaction submission, and checkpoint streaming.
Move filtered and paginated queries to GraphQL on Mainnet — transactions by address, events by type, and objects by owner and type. These are the methods with no gRPC equivalent. See Sui GraphQL endpoint.
On Testnet, which has no GraphQL endpoint, use gRPC.

Chainstack Sui endpoints

Both interfaces are on the same node. Copy your HTTPS endpoint (shown below as YOUR_CHAINSTACK_ENDPOINT, with its auth token built in) from Chainstack — see View node access and credentials. The gRPC endpoint is the host and port below, and the GraphQL endpoint is the HTTPS endpoint with /graphql appended.

Interface	Endpoint	Authentication
gRPC	`sui-mainnet.core.chainstack.com:443`	`x-token` metadata header
GraphQL (Mainnet)	`YOUR_CHAINSTACK_ENDPOINT/graphql`	auth token, basic auth, or `x-token` header

Testnet gRPC is sui-testnet.core.chainstack.com:443; Testnet has no GraphQL endpoint. For every authentication option, see Authentication methods available on Chainstack. See Sui tooling for SDK setup and per-language connection code.

Method mapping

Sui’s gRPC API is organized into services under sui.rpc.v2. Most read and write JSON-RPC methods map directly to a gRPC call. The query methods with no gRPC equivalent map to GraphQL on Mainnet. A few analytics methods come from Sui’s indexer, and neither interface serves them. The tables below give the path for each common JSON-RPC method.

Maps to gRPC

JSON-RPC method	gRPC service and method
`sui_getChainIdentifier`	`LedgerService/GetServiceInfo` (read `chainId`)
`sui_getLatestCheckpointSequenceNumber`	`LedgerService/GetServiceInfo` (read `checkpointHeight`)
`sui_getCheckpoint`	`LedgerService/GetCheckpoint`
`sui_getObject`	`LedgerService/GetObject`
`sui_multiGetObjects`	`LedgerService/BatchGetObjects`
`sui_getTransactionBlock`	`LedgerService/GetTransaction`
`sui_multiGetTransactionBlocks`	`LedgerService/BatchGetTransactions`
`suix_getLatestSuiSystemState`	`LedgerService/GetEpoch` (system state in read mask)
`suix_getCommitteeInfo`	`LedgerService/GetEpoch` (committee in read mask)
`sui_getProtocolConfig`	`LedgerService/GetEpoch` (protocol config in read mask)
`suix_getBalance`	`StateService/GetBalance`
`suix_getAllBalances`	`StateService/ListBalances`
`suix_getCoins`	`StateService/ListOwnedObjects` (filter `type: 0x2::coin::Coin`)
`suix_getCoinMetadata`	`StateService/GetCoinInfo`
`suix_getTotalSupply`	`StateService/GetCoinInfo`
`suix_getOwnedObjects`	`StateService/ListOwnedObjects`
`suix_getDynamicFields`	`StateService/ListDynamicFields`
`suix_getStakesByIds`	`LedgerService/BatchGetObjects` (the stake object IDs, with `json` in the read mask)
`sui_dryRunTransactionBlock`	`TransactionExecutionService/SimulateTransaction`
`sui_devInspectTransactionBlock`	`TransactionExecutionService/SimulateTransaction` (`checksEnabled: false`)
`sui_executeTransactionBlock`	`TransactionExecutionService/ExecuteTransaction`
`sui_getNormalizedMoveModule`	`MovePackageService/GetPackage`
`sui_getNormalizedMoveFunction`	`MovePackageService/GetFunction`
`sui_getNormalizedMoveStruct`	`MovePackageService/GetDatatype`
`suix_resolveNameServiceAddress`	`NameService/LookupName`
`suix_resolveNameServiceNames`	`NameService/ReverseLookupName`

No gRPC equivalent — use GraphQL

These methods have no gRPC equivalent. On Mainnet, use the GraphQL query in the table. Testnet has no GraphQL endpoint, so these queries are available on Mainnet only.

JSON-RPC method	GraphQL query
`suix_queryTransactionBlocks`	`transactions` with a `filter`, or `transactions` on an `address`
`suix_queryEvents`	`events` with a `filter`
`sui_getCheckpoints`	`checkpoints`
`suix_getStakes`	`objects` on an `address`, filtered by type `0x3::staking_pool::StakedSui`
`suix_getValidatorsApy`	No GraphQL field. Derive APY from each validator’s staking pool exchange rates across epochs, or use a staking analytics provider
`suix_subscribeEvent`, `suix_subscribeTransaction`	No GraphQL subscriptions. Stream checkpoints over gRPC with `SubscriptionService/SubscribeCheckpoints` and filter transactions and events client-side

Filtered transactions and all events queries cover about the most recent 90 days, a shorter window than point lookups. See How far back GraphQL history goes.

Indexer and analytics methods

A few JSON-RPC methods return aggregated analytics that come from Sui’s indexer layer, not from a full node. A full node — Sui’s or Chainstack’s — does not serve them over gRPC. Get the underlying data these ways:

JSON-RPC method	What to use instead
`suix_getEpochs`	On Mainnet, list epochs with the GraphQL `epochs` query; epochs that started before the GraphQL history window return `null` fields. For the current epoch’s validators, committee, and gas price, call `LedgerService/GetEpoch` (gRPC).
`suix_getNetworkMetrics`, `suix_getAddressMetrics`, `suix_getMoveCallMetrics`	Network analytics (TPS, active addresses, popular calls). Derive them by indexing your Chainstack node’s checkpoint stream (gRPC `SubscriptionService/SubscribeCheckpoints`) into your own store, or use a Sui analytics provider. Most applications do not need these.

gRPC streaming exposes only SubscribeCheckpoints, not per-event subscriptions. For event streams, subscribe to checkpoints over gRPC and filter events client-side.

gRPC quickstart

The fastest way to confirm your endpoint and explore the API is grpcurl. Sui gRPC has server reflection enabled, so you can list services and call methods without compiling proto files.

grpcurl -H "x-token: YOUR_X_TOKEN" \
  sui-mainnet.core.chainstack.com:443 \
  list

grpcurl -H "x-token: YOUR_X_TOKEN" \
  sui-mainnet.core.chainstack.com:443 \
  sui.rpc.v2.LedgerService/GetServiceInfo

grpcurl -H "x-token: YOUR_X_TOKEN" \
  -d '{"sequence_number": 296000000}' \
  sui-mainnet.core.chainstack.com:443 \
  sui.rpc.v2.LedgerService/GetCheckpoint

GetServiceInfo returns the chain, current epoch, and the node’s checkpoint range:

{
  "chainId": "4btiuiMPvEENsttpZC7CZ53DruC3MAgfznDbASZ7DR6S",
  "chain": "mainnet",
  "epoch": "1184",
  "checkpointHeight": "296723264",
  "lowestAvailableCheckpoint": "253124671",
  "server": "sui-node/1.74.1-8fc60f1fa966"
}

To inspect any service’s methods and message shapes, describe it:

grpcurl -H "x-token: YOUR_X_TOKEN" \
  sui-mainnet.core.chainstack.com:443 \
  describe sui.rpc.v2.LedgerService

gRPC from code

In TypeScript, use the official Sui SDK (@mysten/sui). Its default gRPC-Web transport works against Chainstack over HTTPS — in the browser and in Node.js — so you only need your node URL as baseUrl. For server-side apps that prefer native gRPC over HTTP/2, pass a native transport instead (see Sui tooling for the native setup). From other languages, generate stubs from Sui’s proto definitions and attach the x-token metadata.

Use recent client versions — @mysten/sui 2.16 or later (and @grpc/grpc-js 1.14 or later for the native transport). Older releases mishandle gRPC streams and produce intermittent RST and internal errors under load; current versions are reliable.

// npm install @mysten/sui
// Default gRPC-Web transport over HTTPS — works in the browser and in Node.js.
import { SuiGrpcClient } from '@mysten/sui/grpc';

const client = new SuiGrpcClient({
  network: 'mainnet',
  baseUrl: 'YOUR_CHAINSTACK_SUI_HTTPS_ENDPOINT',
});

// High-level helpers on client.core; raw services on client.ledgerService, etc.
const gasPrice = await client.core.getReferenceGasPrice();
console.log(gasPrice.referenceGasPrice);

import grpc

# Native gRPC channel over TLS; x-token metadata on every call
channel = grpc.secure_channel(
    "sui-mainnet.core.chainstack.com:443",
    grpc.ssl_channel_credentials(),
)
metadata = (("x-token", "YOUR_X_TOKEN"),)

# Using stubs generated from Sui's protos, e.g. LedgerService:
# from sui.rpc.v2 import ledger_service_pb2, ledger_service_pb2_grpc
# stub = ledger_service_pb2_grpc.LedgerServiceStub(channel)
# resp = stub.GetServiceInfo(
#     ledger_service_pb2.GetServiceInfoRequest(), metadata=metadata
# )
# print(resp.checkpoint_height)

The default gRPC-Web transport shown above works in the browser and in Node.js. Native gRPC over HTTP/2 is server-side only; use it when you specifically need native gRPC.

Next steps

Sui tooling — SDKs, gRPC, and GraphQL connection setup.
Sui gRPC endpoint — checkpoint retention and authentication.
Sui GraphQL endpoint — GraphQL authentication, filters, history windows, and limits.
Sui gRPC overview — Sui’s own gRPC reference.
Sui JSON-RPC migration guide — the upstream mapping and SDK migration notes.

Platform

Pricing

Core

Add-ons

Security

Migrate to Chainstack

Web3 [de]coded

MCP servers

Marketplace

Chainstack Compare

Chainstack ChatGPT plugin

Chainstack DLP browser extension

Protocols

Advanced APIs

Tooling

Migrate Sui from JSON-RPC to gRPC and GraphQL

What is being removed

Chainstack Sui endpoints

Method mapping

Maps to gRPC

No gRPC equivalent — use GraphQL

Indexer and analytics methods

gRPC quickstart

gRPC from code

Next steps

​What is being removed

​Chainstack Sui endpoints

​Method mapping

​Maps to gRPC

​No gRPC equivalent — use GraphQL

​Indexer and analytics methods

​gRPC quickstart

​gRPC from code

​Next steps

What is being removed

Chainstack Sui endpoints

Method mapping

Maps to gRPC

No gRPC equivalent — use GraphQL

Indexer and analytics methods

gRPC quickstart

gRPC from code

Next steps