Sui RPC Network: Endpoints, Methods, and Debugging

Sui RPC decision checklist

Before you connect an app to the Sui RPC network, run through this checklist:

• Confirm whether you need Mainnet, Testnet, or Devnet. The network determines the endpoint, the state you can read, and the transactions you can submit.
• Check which API style the endpoint supports: JSON-RPC, GraphQL, or gRPC. Sui is moving away from JSON-RPC, so new integrations should verify long-term access.
• Review request limits and fair-use policy. Public Sui fullnodes are rate-limited and are not intended for production traffic.
• Ask about WebSocket support if you need to subscribe to transactions, checkpoints, or Move events.
• Decide whether you need historical data beyond recent checkpoints, which can affect archive requirements.
• Plan for redundancy. High-traffic events such as NFT mints can overwhelm a single provider.
• Test the exact RPC methods and payload formats your app will call before launch, and include fallback endpoints in your client configuration.

What is the Sui RPC network?

Sui is a layer-1 blockchain with an object-centric data model and parallel transaction execution. The Sui RPC network is the set of endpoints that full nodes expose so wallets, explorers, indexers, games, and backend services can interact with the network. Through an RPC endpoint, an application can read balances, query objects and transactions, dry-run Move calls, and submit transaction blocks for execution.

Unlike EVM networks, Sui does not expose a single canonical block number in the same way. The network advances through checkpoints, and most clients reference checkpoint sequence numbers or epoch boundaries when tracking state. This difference matters when you are building an indexer or when you are trying to reason about finality. A transaction is considered final once the checkpoint that includes it has been certified by the validator set.

There are two common ways to access the Sui RPC network:

• Use official public fullnodes maintained by Sui. These are convenient for prototyping but are rate-limited and unsuitable for production apps.
• Use a managed RPC provider such as OnFinality. Provider-hosted endpoints typically offer higher throughput, monitoring, failover, and dedicated node options for teams that need isolated capacity.

For production workloads, you should treat RPC access as infrastructure. That means evaluating request limits, uptime characteristics, support, and redundancy rather than just copying an endpoint URL into a config file.

Sui RPC endpoint basics

The common public Sui network endpoints are:

Network	Endpoint	Notes
Mainnet	https://fullnode.mainnet.sui.io:443	Official public endpoint, rate-limited
Testnet	https://fullnode.testnet.sui.io:443	Useful for development and testing
Devnet	https://fullnode.devnet.sui.io:443	Early features, state resets possible

Provider endpoints differ. OnFinality publishes the current Sui RPC details on the Sui network page. If you use a managed service, you normally receive a URL that is load-balanced across multiple full nodes and can be used with standard JSON-RPC or GraphQL clients.

When configuring a network, use HTTPS and the default 443 port in almost all cases. Do not add path segments to the endpoint unless the provider documents a specific routing path. Sui does not use an EVM chain ID, so wallets and apps identify the network by the endpoint itself. When adding the network to a wallet, use the provider-provided network name, RPC URL, and SUI symbol.

How to make a Sui RPC request

Sui RPC endpoints speak JSON-RPC 2.0. A basic request has a method name, optional params, and an id that you can use to match responses when batching multiple requests.

The following curl example calls suix_getLatestCheckpointSequenceNumber to fetch the current checkpoint sequence:

curl -X POST "https://YOUR_SUI_RPC_URL" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"suix_getLatestCheckpointSequenceNumber","params":[],"id":1}'

To read a balance, pass the owner address as a hexadecimal string:

curl -X POST "https://YOUR_SUI_RPC_URL" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"suix_getBalance","params":["0xYOUR_ADDRESS"],"id":1}'

If you are using TypeScript, the same request can be made with fetch:

const rpcUrl = "https://YOUR_SUI_RPC_URL";

const response = await fetch(rpcUrl, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "suix_getBalance",
    params: ["0xYOUR_ADDRESS"]
  })
});

const result = await response.json();
console.log(result.result);

Sui uses SuiJSON, a restricted JSON format for Move arguments. Large unsigned integers such as u64 and u128 must be encoded as strings, and array values must be homogeneous. If you see a type-coercion error, check that your numbers are strings and your address format is correct.

Common Sui RPC methods

The Sui JSON-RPC API uses suix_ and sui_ method prefixes. A few methods are widely used:

• suix_getLatestCheckpointSequenceNumber — get the current checkpoint height.
• suix_getBalance — get SUI or coin balance for an address.
• suix_getObject — fetch object data by object ID.
• suix_dryRunTransactionBlock — simulate a transaction block before executing it.
• suix_executeTransactionBlock — submit a signed transaction block.
• suix_getTransactions — query transaction blocks by filters.

These methods are useful for building a basic Sui client. For example, before submitting a transaction, you should always call suix_dryRunTransactionBlock to check that the Move function accepts your inputs and that the transaction effects are what you expect.

Because Sui Foundation has deprecated JSON-RPC on mainnet full nodes, check whether the provider also supports GraphQL or gRPC. Several RPC providers, including OnFinality, are adding or already exposing alternative data access methods. You can inspect the current endpoint details on the Sui network page.

How to choose a Sui RPC provider

A Sui RPC provider decision should be based on the workload you are serving. The table below lists the criteria that matter most:

Criterion	What to check	Why it matters
Mainnet/testnet access	Does the provider expose both networks?	You need isolated testnet and mainnet endpoints for development and production.
API surface	Does it support JSON-RPC, GraphQL, gRPC, or WebSocket?	Sui is migrating away from JSON-RPC, so future-proof access matters.
Request limits	What is the documented throughput or fair-use policy?	Public endpoints are rate-limited; production apps need predictable capacity.
Historical data	Does it offer checkpoint history or archive access?	Indexers and analytics tools often need data beyond the latest few checkpoints.
Redundancy	Is the endpoint backed by multiple nodes and regions?	A single node can become a bottleneck during network events.
Support	Is there onboarding and 24-hour support?	High-traffic launches benefit from advance coordination.
Cost model	Is pricing based on requests, nodes, or both?	The right model depends on whether you need shared API access or a dedicated node.

Before committing, run a few simple requests from different regions and measure latency. Then review the provider's documentation for rate-limit headers, response codes, and any differences between JSON-RPC and GraphQL behavior.

For shared access, OnFinality's API service provides managed RPC endpoints on supported networks. For teams that need isolated capacity or custom configuration, a dedicated node gives you your own Sui full node. See RPC pricing and the full list of supported RPC networks when comparing options.

Common Sui RPC failure modes and debugging

Even with a good provider, you will encounter RPC errors. The most common patterns are:

• 429 Too Many Requests — you exceeded the rate limit. Use exponential backoff, batch requests, or move to a paid or dedicated endpoint.
• 503 Service Unavailable — the full node or load balancer is overloaded. Check provider status and add failover to another provider.
• Invalid SuiJSON — a number was sent as a JSON number instead of a string, or an array was not homogeneous. Review the SuiJSON coercion rules.
• Object not found — the object ID or digest is incorrect, or the object was deleted. Verify the object exists on the correct network.
• WebSocket disconnects — subscriptions can drop during long sessions. Reconnect with a retry/backoff strategy and resubscribe after reconnect.
• Transaction execution errors — use suix_dryRunTransactionBlock first to catch Move-level failures before submitting a signed transaction.

When debugging, start with a single request from a tool like curl, verify the response format, then move to the full client flow. If a method works on one provider and not another, compare the API version and the supported methods listed in the provider docs.

For finality-related issues, query the checkpoint sequence number before and after submitting a transaction. If a transaction is not visible immediately, it may still be waiting for checkpoint certification. Avoid assuming a transaction has failed solely because it is not in the first response you receive.

Key Takeaways

• The Sui RPC network connects applications to Sui full nodes for reading state and submitting transactions.
• Official public endpoints are suitable for prototyping but are rate-limited and not recommended for production.
• Sui is moving from JSON-RPC to GraphQL and gRPC, so new projects should confirm the provider's long-term API support.
• Evaluate providers on network coverage, request limits, historical data, redundancy, and support.
• Test with dryRunTransactionBlock, batch requests when possible, and plan for provider failover before launch.
• OnFinality offers managed Sui RPC access through the API service and dedicated nodes. Review RPC pricing and supported networks to pick the right fit.

Frequently Asked Questions

What is the Sui RPC network?

The Sui RPC network is the collection of full-node endpoints and APIs that allow clients to read Sui data, submit transactions, and subscribe to network events. It is the standard way for wallets and dApps to interact with Sui.

Can I use the public Sui RPC endpoint in production?

The public fullnode endpoint can handle small-scale testing, but Sui's own documentation warns that it is rate-limited to roughly 100 requests per 30 seconds. Production applications should use a managed RPC provider or run a dedicated full node.

Does Sui RPC support WebSocket?

Many Sui RPC providers support WebSocket connections for subscriptions, but availability varies by provider and network. Check the provider's documentation for supported subscription methods and reconnection guidance.

Is JSON-RPC going away on Sui?

Sui Foundation has announced plans to disable JSON-RPC on mainnet full nodes in 2026 and recommends GraphQL or gRPC for new integrations. When evaluating a provider, ask which API styles are supported today and which are planned.

Related resources

• Sui network page
• API service
• Dedicated nodes
• RPC pricing

Originally published at OnFinality.