Sui tooling

Sui blockchain development tools guide. Use gRPC, JSON-RPC, the TypeScript SDK, Rust SDK, Python pysui, and Go SDK to build Sui applications with Chainstack.

Get started with a reliable Sui RPC endpoint to use the tools below. Your Chainstack Sui node serves both gRPC and JSON-RPC on the same endpoint.

Sui Foundation retires its public JSON-RPC endpoints by Jul 31, 2026. Chainstack’s own JSON-RPC keeps working, but gRPC is the path forward — see Migrate Sui from JSON-RPC to gRPC.

gRPC API

Sui nodes on Chainstack support gRPC for high-performance access. gRPC uses HTTP/2 and Protocol Buffers for binary serialization, which makes payloads smaller and adds server-side streaming — ideal for indexers, backends, and low-latency lookups. gRPC is the forward path as Sui deprecates JSON-RPC.

Endpoint and authentication

Your Sui gRPC endpoint is sui-mainnet.core.chainstack.com:443 (testnet: sui-testnet.core.chainstack.com:443), with TLS. Authenticate by passing your token in the x-token metadata header on every call. To find your endpoint and token on Chainstack, see View node access and credentials.

Explore with grpcurl

Sui gRPC has server reflection enabled, so grpcurl can list services and call methods without compiling proto files:

List services

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

The node exposes six sui.rpc.v2 services:

Service	Use it for
LedgerService	Checkpoints, objects, transactions, epochs, and node info
StateService	Balances, coins, owned objects, and dynamic fields
TransactionExecutionService	Executing and simulating transactions
SubscriptionService	Streaming checkpoints
MovePackageService	Move packages, modules, functions, and datatypes
NameService	SuiNS name resolution

gRPC from code

In TypeScript, use the official @mysten/sui SDK. Its default gRPC-Web transport works against Chainstack over HTTPS — including from the browser — so the simplest setup needs only your node URL as baseUrl. For server-side apps that prefer native gRPC over HTTP/2, pass a native transport instead. From other languages, generate typed stubs from Sui’s proto definitions and connect over native gRPC. Authenticate with your node’s x-token — carried in the endpoint URL, or as x-token metadata on native-gRPC calls — and use recent client versions — @mysten/sui 2.16+ and @grpc/grpc-js 1.14+ — since older releases produce intermittent gRPC errors under load.

TypeScript (gRPC-Web)

// 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',
});

const gasPrice = await client.core.getReferenceGasPrice();
console.log(gasPrice.referenceGasPrice);

// npm install @mysten/sui @protobuf-ts/grpc-transport @grpc/grpc-js
// Native gRPC over HTTP/2 — server runtimes only.
import { SuiGrpcClient } from '@mysten/sui/grpc';
import { GrpcTransport } from '@protobuf-ts/grpc-transport';
import { ChannelCredentials } from '@grpc/grpc-js';

const client = new SuiGrpcClient({
  network: 'mainnet',
  transport: new GrpcTransport({
    host: 'sui-mainnet.core.chainstack.com:443',
    channelCredentials: ChannelCredentials.createSsl(),
    meta: { 'x-token': 'YOUR_X_TOKEN' },
  }),
});

const gasPrice = await client.core.getReferenceGasPrice();
console.log(gasPrice.referenceGasPrice);

import grpc

channel = grpc.secure_channel(
    "sui-mainnet.core.chainstack.com:443",
    grpc.ssl_channel_credentials(),
)
metadata = (("x-token", "YOUR_X_TOKEN"),)

# With stubs generated from Sui's protos:
# stub = ledger_service_pb2_grpc.LedgerServiceStub(channel)
# resp = stub.GetServiceInfo(
#     ledger_service_pb2.GetServiceInfoRequest(), metadata=metadata
# )
# print(resp.checkpoint_height)

const grpc = require('@grpc/grpc-js');

const credentials = grpc.credentials.createSsl();
const metadata = new grpc.Metadata();
metadata.add('x-token', 'YOUR_X_TOKEN');

// With stubs generated from Sui's protos:
// const client = new LedgerServiceClient(
//   'sui-mainnet.core.chainstack.com:443', credentials);
// client.getServiceInfo({}, metadata, (err, resp) => {
//   console.log(resp.checkpointHeight);
// });

package main

import (
    "context"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
)

func main() {
    creds := credentials.NewTLS(nil)
    conn, err := grpc.Dial(
        "sui-mainnet.core.chainstack.com:443",
        grpc.WithTransportCredentials(creds),
    )
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    ctx := metadata.AppendToOutgoingContext(
        context.Background(), "x-token", "YOUR_X_TOKEN",
    )
    _ = ctx // pass ctx to your generated gRPC client calls
}

The default gRPC-Web transport works in both the browser and server runtimes, so it is the simplest choice for most apps. The native gRPC transport (HTTP/2) is server-side only — use it when you specifically need native gRPC.

JSON-RPC API

Interact with your Sui node using the Sui JSON-RPC API. Chainstack’s JSON-RPC endpoints keep working after Sui’s public endpoints shut down, so this is a valid path while you migrate to gRPC.

Use your Chainstack Sui RPC endpoint to make API calls. Example to get the latest checkpoint:

cURL

curl --request POST \
  --url YOUR_CHAINSTACK_ENDPOINT \
  --header 'Content-Type: application/json' \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sui_getLatestCheckpointSequenceNumber",
    "params": []
  }'

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

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

import requests

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sui_getLatestCheckpointSequenceNumber",
    "params": []
}

response = requests.post('YOUR_CHAINSTACK_ENDPOINT', json=payload)
print(response.json()['result'])

Sui TypeScript SDK

The Sui TypeScript SDK is the official SDK for building Sui applications.

Installation

npm install @mysten/sui.js

Basic usage

Connection

import { SuiClient, getFullnodeUrl } from '@mysten/sui.js/client';

// Connect to your Chainstack node
const client = new SuiClient({
  url: 'YOUR_CHAINSTACK_ENDPOINT'
});

// Get latest checkpoint
const checkpoint = await client.getLatestCheckpointSequenceNumber();
console.log('Latest checkpoint:', checkpoint);

import { SuiClient } from '@mysten/sui.js/client';

const client = new SuiClient({
  url: 'YOUR_CHAINSTACK_ENDPOINT'
});

// Get objects owned by an address
const objects = await client.getOwnedObjects({
  owner: '0x...',
  options: {
    showType: true,
    showContent: true,
  }
});

import { SuiClient } from '@mysten/sui.js/client';
import { TransactionBlock } from '@mysten/sui.js/transactions';
import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';

const client = new SuiClient({
  url: 'YOUR_CHAINSTACK_ENDPOINT'
});

const keypair = Ed25519Keypair.generate();
const tx = new TransactionBlock();

// Add transaction commands
tx.transferObjects([objectId], recipient);

// Sign and execute
const result = await client.signAndExecuteTransactionBlock({
  signer: keypair,
  transactionBlock: tx,
});

Sui Rust SDK

The Sui Rust SDK provides comprehensive Rust bindings for Sui.

Installation

Add to your Cargo.toml:

sui-sdk = { git = "https://github.com/mystenlabs/sui", package = "sui-sdk" }
tokio = { version = "1.2", features = ["full"] }
anyhow = "1.0" 

Basic usage

use sui_sdk::SuiClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sui = SuiClientBuilder::default()
        .build("YOUR_CHAINSTACK_ENDPOINT")
        .await?;
    
    let checkpoint = sui.read_api().get_latest_checkpoint_sequence_number().await?;
    println!("Latest checkpoint: {}", checkpoint);
    
    Ok(())
}

Python SDK (pysui)

pysui is a community-maintained Python SDK for Sui.

Installation

pip install pysui

Basic usage

from pysui import SuiConfig, SyncClient

# Configure client with your Chainstack endpoint
config = SuiConfig.custom_config(
    rpc_url="YOUR_CHAINSTACK_ENDPOINT"
)

client = SyncClient(config)

# Get latest checkpoint
checkpoint = client.get_latest_checkpoint_sequence_number()
print(f"Latest checkpoint: {checkpoint.result_data}")

Go SDK

The Sui Go SDK provides Go language bindings for Sui.

Installation

go get github.com/block-vision/sui-go-sdk

Basic usage

package main

import (
    "context"
    "fmt"
    "github.com/block-vision/sui-go-sdk/sui"
)

func main() {
    client := sui.NewSuiClient("YOUR_CHAINSTACK_ENDPOINT")
    
    ctx := context.Background()
    checkpoint, err := client.SuiGetLatestCheckpointSequenceNumber(ctx)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Latest checkpoint: %s\n", checkpoint)
}