How to get a Sui RPC endpoint for gaming (2026 guide)

TL;DR

The moment a Sui game gets popular is the moment its RPC endpoint decides whether players see a working inventory or a spinning loader. On Sui, one avatar with equipped items is a tree of nested objects, every sponsored transaction runs through your backend, and a hyped NFT drop funnels thousands of buyers at a single Kiosk object — so a shared public node throttles exactly when your launch is working. On top of that, Sui is switching off its public JSON-RPC, though only the public endpoints — a managed node keeps JSON-RPC alive while you move to gRPC. This guide shows how to get a Sui RPC endpoint for gaming that survives both the launch spike and the shutdown.

Tomorrow, Sui Foundation's public mainnet JSON-RPC endpoints shut down.

Full decommission lands mid-October.

Still calling JSON-RPC? Move to gRPC or GraphQL RPC through a data provider already running the new stack.

— Sui Developers (@suidevelopers) July 27, 2026

What is a Sui RPC endpoint for gaming

A Sui RPC endpoint is the connection your game client and backend use to talk to a Sui full node — reading object state, simulating and submitting transactions, and subscribing to on-chain events. Sui does not speak Ethereum’s JSON-RPC dialect. It exposes its own object-centric API, where every in-game item, character, currency balance, and NFT is an addressable object with its own version number, and every read is a query against that object graph. That API is available as JSON-RPC and, increasingly, as a typed gRPC service — the interface Sui is investing in going forward.

In a game, this endpoint is doing something on nearly every screen and every tap:

• Loading a player’s inventory by fetching their owned objects and versions (suix_getOwnedObjects)
• Rendering that inventory with proper art and metadata through the Sui Object Display standard (sui_getObject with display)
• Reading a composed asset — a character with equipped items nested as dynamic fields (suix_getDynamicFields)
• Estimating gas and submitting a sponsored transaction so the player never touches a gas token (sui_dryRunTransactionBlock, sui_executeTransactionBlock)
• Resolving a loot drop or critical hit through on-chain randomness (a transaction plus a read of the result object)
• Reading marketplace listings, transfer policies, and royalty rules held in a Kiosk shared object (sui_getObject)

You can review the full list of supported interfaces and methods in the Sui API reference documentation.

Endpoint quality is felt directly by players. On Sui’s sub-second finality, a confirmed trade should land in a player’s inventory almost instantly — but a throttled endpoint turns that into a visible stall, and during a tournament or a limited drop a shared public node simply stops answering when a few thousand players act at once.

What Sui gives game developers (and what it asks of your RPC endpoint)

Sui was designed with games in mind, and its gaming primitives are the reason studios pick it — but each one lands as a specific pattern of calls on your endpoint. This is the part a generic “get an RPC URL” guide misses: on Sui, your feature choices are your RPC load profile. The full feature set is documented in the Sui gaming developer reference; here is how the headline primitives translate into endpoint demand.

Sui gaming primitive	What it gives the game	What it asks of your RPC endpoint
zkLogin onboarding	Sign-in with Google/Twitch, no seed phrase	Owned-object reads on every first load; a marketing push spikes them all at once
Sponsored transactions	The game pays the player’s gas	Backend dry-run + executeTransactionBlock on every action — write and simulate load scales with actions, not wallets
Dynamic NFTs + dynamic fields	Composable, upgradeable items nested in a character	getObject + getDynamicFields fan-out on every avatar render
Kiosk + transfer policy	Marketplace with enforced creator royalties	Shared-object reads and writes; consensus contention on a hot drop
On-chain randomness	Trustless loot boxes and crits	A transaction plus a result-object read per pull
Closed-loop tokens	True-ownership in-game currency	Balance reads per session, minting/burning writes on rewards

The through-line: a single player action rarely maps to a single RPC call. Rendering one equipped avatar can fan out into a dozen object reads, and because sponsored transactions route through your infrastructure, your backend — not the player’s wallet — is the thing hammering the endpoint. Size for that fan-out, or the launch that proves your game breaks it.

How Sui RPC differs from EVM chains

If your team is coming from Ethereum, Polygon, or BNB Smart Chain, the mental model has to change before the code does. Sui is built on the Move VM and an object-centric data model, not the EVM’s account-and-storage-slot model, and that difference reaches all the way up into how you design RPC calls.

On an EVM chain you read a contract’s storage by calling a method and decoding the return; balances and ownership live inside contract state. On Sui, assets are first-class objects owned by addresses. To load a player’s inventory you query their owned objects directly — there is no eth_getLogs, no eth_call against a token contract, and no ABI decoding. Reads target object IDs and versions; writes are programmable transaction blocks that can chain multiple Move calls atomically. Owned objects can settle through a fast path without full consensus ordering, which is part of why Sui hits sub-second finality — but transactions that touch a shared object, like a marketplace Kiosk or a global leaderboard, are sequenced through consensus, and that is where a launch-day crowd creates contention.

The tooling stack is entirely separate, too. There is no MetaMask-and-ethers.js path here. Sui’s official client is the @mysten/sui TypeScript SDK, plus official Rust, Python (pysui), and Go SDKs, and contracts are written in Move rather than Solidity. The practical takeaway for RPC selection: an EVM-only provider or a generic “we support every chain” gateway often lags on Sui-native features. The one that matters most right now is gRPC support, because Sui is retiring its public JSON-RPC and steering new development onto the gRPC API.

Sui RPC endpoint options

Public vs private Sui RPC endpoints for gaming

For a game, the public-vs-private decision is really a question of what happens during your busiest minute, not your average one — and on Sui it is now also a question of which interface is still answering in late 2026. Sui Foundation runs public full nodes for development, but its own documentation is blunt about production use, and those public endpoints are on a shutdown schedule.

Official public endpoints:

• Mainnet: https://fullnode.mainnet.sui.io:443
• Testnet: https://fullnode.testnet.sui.io:443

⚠️ These public endpoints are shared, rate-limited, and being switched off: Sui disables public mainnet JSON-RPC the week of July 27, 2026 and fully decommissions it by mid-October 2026. The Sui data-serving docs explicitly state “Do not use those for production” and point developers to professional RPC providers. Only the public endpoints are affected — JSON-RPC stays available on managed nodes.

Public endpoint	Private endpoint (Chainstack)
Access	Free and open	Restricted access
Resources	Shared infrastructure	Dedicated resources
Best use case	Development & testing	Production workloads
JSON-RPC after Oct 2026	Decommissioned	Still served on the same node
gRPC access	Not guaranteed	JSON-RPC + gRPC on one endpoint
Behavior on a launch drop	Throttles when the crowd hits one Kiosk	Sized to your peak RPS

For a game, the decision makes itself: a public endpoint that throttles the instant a thousand players rush a drop and loses its JSON-RPC interface in October 2026 is not infrastructure you can ship a player economy on. A managed endpoint that serves both JSON-RPC and gRPC lets you keep shipping today and migrate on your own schedule.

📖 For a detailed comparison of Sui RPC providers, see Best Sui RPC providers for production in 2026.

Full node vs archive Sui node

For a game, historical data access is what lets you reconstruct how a player’s inventory or a marketplace looked at any past point — the difference between “show me this item now” and “show me every owner and price this legendary sword has ever had.”

Full node access	Archive node access
Current player inventory and object state	Full ownership history of an NFT or in-game item
Live event subscriptions during a match	Replaying marketplace and Kiosk activity for analytics and anti-fraud
Confirming a trade at the latest checkpoint	Reconstructing leaderboard or economy state at a past epoch

A Sui full node serves a moving window of recent checkpoints — tens of millions of them (a Chainstack node held roughly 43 million checkpoints in a mid-2026 snapshot) — but not the full ledger from genesis. For player-facing analytics, tournament settlement, and compliance on real-money assets that reach further back, an archive node is what lets you backfill an in-game economy dashboard, audit a disputed trade, or rebuild a season’s leaderboard without running your own indexer. That deep history is exactly what the public load balancers do not retain.

HTTPS vs WebSockets

Games are event-driven, so the transport choice matters more here than for a typical read-heavy backend. A persistent connection that pushes a “battle resolved” or “you were outbid” event to the client is the difference between a responsive game and one that polls and feels laggy.

Feature	HTTPS	WebSocket
Model	Request/response	Persistent connection
Complexity	Simple operationally	Requires reconnect/heartbeat logic
Best for	Inventory reads, transaction submission, dry-run simulation	Live match events, marketplace bid/outbid notifications, reward drops
Latency	Standard	Lower for frequent updates
Connection overhead	Per request	One-time handshake

One nuance specific to Sui’s migration: event subscriptions (suix_subscribeEvent) run over the JSON-RPC WebSocket and keep working on a managed node — gRPC streaming currently exposes only checkpoint subscriptions, not per-event ones. So for a live game feed you either keep suix_subscribeEvent on JSON-RPC, or subscribe to the checkpoint stream over gRPC and filter events client-side. Either way, the durable path runs through a provider that keeps both interfaces on the same node rather than a public endpoint that is going away.

How to get a private Sui RPC endpoint for gaming with Chainstack

Chainstack builds specifically for blockchain gaming infrastructure — geo-load-balanced nodes you can place close to your player base, Bolt fast-sync to stand up a node in hours instead of days, IPFS storage for in-game asset data, and headroom to handle billions of in-game transactions without performance drops. Deploying a private Sui RPC node on Chainstack takes a few minutes:

1. Log in to the Chainstack console (or create an account).
2. Create a new project
3. Select Sui as your blockchain protocol
4. Choose network: Sui Mainnet or Sui Testnet
5. Deploy the node
6. Open Access/Credentials and copy your JSON-RPC (HTTPS) endpoint; the gRPC endpoint is sui-mainnet.core.chainstack.com:443 (testnet: sui-testnet.core.chainstack.com:443)
7. Run a quick connectivity check before wiring it into production code

Both interfaces are served from the same node, so you can start on JSON-RPC today and move calls to gRPC as you go. With the official @mysten/sui SDK, loading a player’s inventory takes only a few lines:

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

// JSON-RPC over your private Chainstack HTTPS endpoint
const client = new SuiClient({ url: 'YOUR_CHAINSTACK_ENDPOINT' });

// Load a player's owned objects, with display metadata for rendering
const inventory = await client.getOwnedObjects({
  owner: '0xPLAYER_ADDRESS',
  options: { showType: true, showContent: true, showDisplay: true },
});
console.log('Items owned:', inventory.data.length);

When you are ready to move a hot path to gRPC — say, low-latency inventory reads or checkpoint streaming for a live feed — the same SDK exposes a gRPC client whose default gRPC-Web transport works over HTTPS from both Node.js and the browser:

import { SuiGrpcClient } from '@mysten/sui/grpc';

// gRPC-Web over HTTPS — just point it at your Chainstack node URL
const grpc = new SuiGrpcClient({ network: 'mainnet', baseUrl: 'YOUR_CHAINSTACK_ENDPOINT' });
const info = await grpc.core.getReferenceGasPrice();
console.log(info.referenceGasPrice);

📖 For the call-by-call JSON-RPC to gRPC mapping and the full integration guide, see the Chainstack Sui tooling documentation.

You can also access Chainstack Sui RPC directly from Claude, Cursor, Codex, Gemini, or Windsurf using Chainstack MCP. Learn more about Chainstack MCP.

Chainlist is EVM-only, so it does not apply to Sui — there is no chain ID to add to a wallet, and any infrastructure you wire up has to speak Sui’s native object API directly.

Chainstack pricing for Sui RPC

Chainstack bills on a flat Request Unit model, which makes a game’s spend easier to forecast than compute-unit pricing that varies by method — handy when a launch event multiplies your call volume overnight. See the full Chainstack pricing page for plan details and overage rates.

Plan	Cost	Requests/Month	RPS	Overage (per 1M extra)
Developer	$0	3M	25	$20
Growth	$49	20M	250	$15
Pro	$199	80M	400	$12.50
Business	$499	200M	600	$10
Enterprise	$990+	400M+	Unlimited	$5

For games that need guaranteed dedicated capacity, Dedicated Nodes start from $0.50/hour plus storage. If your read volume is steady and high — common for a game backend rendering inventories and polling object state — the Unlimited Node add-on lets you fix cost to an RPS tier instead of per-request billing.

How to estimate monthly cost

1. Count the RPC calls behind one player session — inventory render fan-out, sponsored-transaction dry-runs and submissions, marketplace reads
2. Multiply by your expected concurrent and daily active players
3. Add backend load: indexers, leaderboards, anti-fraud reads, and reward distribution
4. Map the total against the plan RPS limits above
5. Then size for the event, not the average: a token drop, tournament, or viral moment can 10x your object reads in minutes, and because sponsored transactions and avatar renders both fan out, a few thousand concurrent players generate the volume a naive per-user estimate would put at tens of thousands.

Production readiness checklist

• Primary + fallback RPC provider configured
• Request timeout policy set
• Retry logic with exponential backoff implemented
• Credentials stored in env/secret manager (never hardcoded)
• Monitoring for latency, error rate, and throttling
• Alerts for sustained degradation
• Off the public fullnode.mainnet.sui.io endpoint before the week of July 27, 2026 mainnet JSON-RPC shutoff
• Inventory-render reads batched (multiGetObjects) so one avatar screen does not fan out into a throttle event
• Sponsored-transaction backend sized separately — its dry-run and submit load scales with player actions, not wallet count
• Kiosk / shared-object contention handled with version-conflict retries for launch drops
• @mysten/sui pinned to 2.16 or later (older releases mishandle gRPC streams under load)

Troubleshooting common Sui RPC issues for games

Issue	How to fix
429 Too Many Requests during a launch or drop	Move off the public fullnode to a managed endpoint sized for peak RPS; batch inventory reads with multiGetObjects and add a client-side rate limiter
Calls to fullnode.mainnet.sui.io stop working after July 2026	Repoint to a managed JSON-RPC endpoint that keeps serving; migrate hot paths to gRPC on the same node when convenient
Avatar or inventory renders half its items	Read burst throttled mid-fan-out; batch getObject/getDynamicFields and use a dedicated endpoint with read headroom
Kiosk purchase fails under load on a hot drop	Shared-object contention during consensus sequencing; retry with backoff on version conflicts, not just on network errors
Item traded but not showing in inventory	Read object effects and the latest version after finality rather than caching a prior version; re-query owned objects
Live event subscription silently stops	Add reconnect + heartbeat logic; keep suix_subscribeEvent on the JSON-RPC WebSocket, or stream checkpoints over gRPC and filter client-side

Conclusion

The failure that actually bites a Sui game is not a slow query — it is a silent, load-triggered break. An avatar that renders three of its four equipped items because a read burst clipped the public throttle. A drop where the first thousand buyers all hit one Kiosk object and half their purchases fail on version conflicts. And then, on schedule, a game still pointed at fullnode.mainnet.sui.io that simply stops getting answers the week of July 27, 2026 — an outage your monitoring blames on your own deploy while the real cause is a public endpoint switched off on time.

The pattern that works is specific to how Sui games load. Move off public endpoints to a private Sui node that serves JSON-RPC and gRPC together, so nothing breaks on the shutdown date and you migrate call by call on your own timeline. Batch your inventory-render reads, size your backend for sponsored-transaction volume rather than wallet count, and give your Kiosk and other shared objects the RPS headroom a launch demands. Then plan capacity around your biggest event, not your quiet Tuesday.

Spin up a free Sui endpoint to test against, and move to Dedicated Nodes when your player economy goes live.

FAQ

Which SDK should I use to connect a Sui game to an RPC endpoint? For TypeScript and JavaScript game backends, use the official @mysten/sui SDK — it handles client setup, object queries, sponsored-transaction building, and exposes a SuiGrpcClient for gRPC. Rust, Python (pysui), and Go SDKs are also available. Pin @mysten/sui to 2.16 or later, since older releases mishandle gRPC streams under load.

Why does one player action generate so many RPC calls on Sui? Because assets are objects, not contract state. A single character with equipped items is a parent object with several dynamic fields, so rendering it means a getObject plus a walk of its getDynamicFields. Add sponsored transactions — where your backend dry-runs and submits on the player’s behalf — and the endpoint load scales with in-game actions, not just player count. This fan-out is the number that predicts when you outgrow a plan tier.

Is a public Sui endpoint good enough for my game? For local development, yes. For anything player-facing, no. Sui’s own docs say not to use the public load balancers for production, they throttle the moment a crowd hits a drop, and public mainnet JSON-RPC is switched off the week of July 27, 2026. A managed endpoint solves reliability, throughput, and longevity at once.

What actually happens to my game when Sui shuts down public JSON-RPC? Only Sui Foundation’s public endpoints (like fullnode.mainnet.sui.io) go dark — mainnet the week of July 27, 2026, fully decommissioned by mid-October 2026. JSON-RPC is not being removed from the node software, so a managed provider keeps serving it. If your game points at the public endpoint, those calls fail; if it points at a private node, nothing breaks and you migrate to gRPC when you choose.

How do I handle a marketplace drop where everyone buys at once? A Kiosk is a shared object, so every purchase is sequenced through consensus — under a hot drop you will see transactions fail on version conflicts rather than on gas. Build retry logic around object versioning, treat contention as a distinct error class from network failures, and run it on an endpoint with the RPS headroom to absorb the spike.

Do I need a separate endpoint for real-time game events? No — you need one provider that keeps both interfaces on the same node. Event subscriptions (suix_subscribeEvent) run over the JSON-RPC WebSocket and keep working; gRPC streaming currently covers checkpoints, not individual events. So build live match feeds and outbid notifications on the JSON-RPC WebSocket, or stream checkpoints over gRPC and filter client-side.

Additional resources

• Sui gaming developer reference — official guide to zkLogin, sponsored transactions, dynamic NFTs, Kiosk, and on-chain randomness for games
• Migrate Sui from JSON-RPC to gRPC — Chainstack’s call-by-call method mapping and gRPC quickstart
• Sui: connecting to RPC and the tooling stack — JSON-RPC, gRPC, and SDK connection setup for Sui
• More Sui tutorials and articles on the Chainstack Blog
• Best Sui RPC providers for production in 2026 — provider comparison across gRPC readiness, retention, and SLA