Black Friday ~40% off Growth and Pro annual plans See offers
  • Agents
  • Pricing

Running your own Sui node: gRPC, pruning, who needs one

Created Nov 13, 2026 Updated Nov 13, 2026
Sui Node logo

Running a Sui node yourself has historically been a commitment. Mysten Labs’ suggested minimum for a full node is 8 physical cores (16 vCPUs), 128 GB of RAM and a 4 TB NVMe drive, and the network expects you to stay on the latest release, which in practice means an upgrade every few weeks.

Two things changed in 2026. Sui moved its supported data interfaces from JSON-RPC to gRPC and GraphQL, and in doing so ended the free archival fallback that many applications relied on without realizing it. And Chainstack Self-Hosted added Sui Mainnet and Sui Testnet as deployment targets in v2.12.0 on July 28, 2026, running the official Sui full node with snapshot-accelerated initial sync. [OPEN, blocker: the supported deployments catalog lists Sui-Node v1.79.1 (Mainnet) and v1.80.0 (Testnet), both below v1.82, and the last release that refreshed the Sui images is v2.64.0 from September 22. Testnet moved to the v1.82 protocol on October 15 and Mainnet to protocol 141 on November 10. Confirm what is shipping now before publishing.]

This piece is about who actually benefits from a Sui node on their own infrastructure, what running one looks like day to day, and how the newer answer compares to the older one.

Why running a Sui node used to be a project

A Sui full node tracks and verifies the state of the chain independently and locally, and serves read requests to clients. It cannot sign transactions the way a validator does, but it re-executes checkpointed transactions and checks them against the validator committee’s signatures, so you do not have to trust anyone else’s answers. What you get from one, according to Sui’s full node documentation:

  • Reads over gRPC and JSON-RPC. Both are served on port 9000. gRPC includes checkpoint streaming, which indexers and bots use to follow the chain without polling.
  • Transaction submission. Full nodes coordinate submission to validators and can optionally execute transactions locally before sending them.
  • Retention control. You decide how many epochs of objects and checkpoints the node keeps, and therefore what it can answer.
  • Independent verification. State sync pulls certified checkpoints from peers and verifies them against the committee. The data you read is data you checked.

It helps to be clear about what a full node is not. Validators order and sign transactions. Full history from genesis lives in a separate archival store, and the GraphQL interface runs on a general-purpose indexer backed by a Postgres-compatible database. A plain full node gives you a retention window, not the whole chain.

Diagram: a Sui full node syncs checkpoints from validators and peers and serves applications on port 9000, while the archival store and the indexer with GraphQL are separate components

The setup burden is where the project part comes in:

  • You do not sync from genesis. Sui’s docs say outright not to: it takes a very long time, consumes a lot of resources and is likely to fill the disk. The seed peers only keep a few epochs of history, so you bootstrap from a snapshot instead. Formal snapshots are protocol-native, verifiable and minimal. RocksDB snapshots are full database copies. Mysten hosts free formal snapshots on Cloudflare R2, which the docs describe as North America only.
  • You configure pruning yourself. Without an active pruning configuration, a node can fill 7 TB or more.
  • gRPC indexing is something you switch on. Setting rpc.enable-indexing: true is a rolling upgrade, and during the initial indexing phase the node might not be able to handle other traffic.
  • You build the network edge. gRPC needs HTTP/2, so the docs suggest a TLS proxy on port 443. P2P needs 8084/UDP open. The Prometheus metrics port (9184) should be restricted, and the admin port (1337) should stay on localhost.
  • You keep up with upgrades. Sui’s docs say full nodes must be updated to the latest version to stay in sync with the network.

None of this is exotic engineering. It is a long list of things that need an owner.

Who actually runs their own Sui node, and why

Sui’s ecosystem is modest in size, and it is worth being precise about that. On November 10, 2026, DefiLlama showed $420.5M in DeFi TVL and $519.89M in stablecoins on Sui, with USDC making up 67.11% of the stablecoin supply. The case for owning a node does not rest on scale. It rests on what a shared endpoint cannot give you.

  • Exchanges and custodians. This is the one audience where the guidance is documented. Sui’s exchange integration guide tells operators to run their own full node for control over availability, retention and read performance, and not to rely on the public fullnode and graphql URLs for production traffic.
  • DeFi and DeepBook trading teams. Market makers, liquidators and arbitrage bots care about how fresh their view of the chain is and about when their node upgrades. gRPC checkpoint streaming gives them a feed without polling, and a node you control lets you decide when to take a release. DeepBook is maintained by Mysten, and its CI tracks mainnet protocol versions, which is a reminder of how closely Sui applications follow protocol upgrades.
  • Indexers and data providers. Teams that build their own datasets want a custom retention window and a stream of checkpoints, and they cannot get either from a rate-limited public endpoint.
  • Stablecoin and payment flows. Sui v1.72 introduced address balances and gasless stablecoin transfers, and Sui reports more than $1 trillion in stablecoin transfer volume since August 2025. Payment operators reconcile against chain state, and a node of their own keeps that reconciliation off a shared endpoint.
  • Wallets and apps that outgrew public endpoints. Sui’s docs describe the public endpoints as rate-limited to about 100 requests per 30 seconds, and as sitting behind load balancers with additional limits on requests per second, concurrent streams and message size.
  • Infrastructure operators. Several independent infrastructure operators are listed as mainnet seed peers in Sui’s own docs, alongside Mysten’s public nodes.

At a glance

AudienceUse caseWhat running your own unlocksExamples
Exchanges and custodiansDeposit and withdrawal detection, balance reconciliationControl over availability, retention and read performance, no shared rate limitsRecommended in Sui’s exchange integration guide
DeFi and DeepBook trading teamsMarket making, liquidations, arbitrageCheckpoint streaming over gRPC, control over upgrade timingNo public examples verified
Indexers and data providersCustom datasets, analyticsCustom retention window, full checkpoint streamNo public examples verified
Stablecoin and payment appsSettlement, reconciliation, gasless transfersReads that do not depend on a shared endpointNo public examples verified
Wallets and appsHigh-volume reads and submissionNo 100-requests-per-30-seconds ceilingNo public examples verified
Infrastructure operatorsServing Sui to othersFull control of the stackSeed peers listed in Sui’s docs

We could not verify which named Sui protocols run their own nodes, so the table names audiences, not companies.

When Sui data is load-bearing for the business, you don’t rent it.

What changed on Sui in 2026: the JSON-RPC sunset and retention

Anyone planning a Sui node today needs to know about the biggest change to how nodes serve data. Sui deprecated JSON-RPC in favor of gRPC and GraphQL, and published a timeline in its JSON-RPC migration guide:

MilestoneTarget date
Disable JSON-RPC on Sui Foundation mainnet full nodesWeek of July 27, 2026 (done)
Stop publishing JSON-RPC snapshotsEnd of August 2026
Disconnect the implicit JSON-RPC to archival fallbackEnd of September 2026
JSON-RPC removed from the full node code in v1.82Testnet: October 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, per Chainstack’s migration doc. Older posts still quote April 2026 and July 31, 2026, and both are superseded by this table.

The last row matters most to operators. A node on an older version stops when the network activates the v1.82 protocol, so you cannot keep JSON-RPC switched on by staying behind.

Timeline of the Sui JSON-RPC retirement in 2026, from the Foundation mainnet nodes in July to removal in v1.82

gRPC is generally available, including polling and streaming. The GraphQL RPC server and the general-purpose indexer are also generally available, although the GraphQL reference is still labeled beta.

The detail that matters most to a node operator is retention. In the old JSON-RPC flow, a request for data the node had pruned could be quietly served from an archival store. Full-node gRPC does not do that. A full node serves only the data inside its retention window, and a request for pruned data returns NOT_FOUND. If your application reads old transactions or objects, you now decide where that history comes from: a longer retention setting on your own node, an archival store, or a provider that keeps a longer window.

Diagram: a Sui full node serves checkpoints from lowestAvailableCheckpoint to the chain tip, and pruned data returns NOT_FOUND

On the managed side, Chainstack’s Sui Global Nodes are Extended full nodes. They hold a window of checkpoints starting at lowestAvailableCheckpoint, not history from genesis. In a response from September 27, 2026, the node held about 89.7 million checkpoints, with a floor dating to roughly January 23, 2026. On Chainstack, Sui Testnet nodes no longer serve JSON-RPC, and Mainnet nodes stop serving it when they upgrade to v1.82. gRPC runs on the same endpoint and token, with no provider switch and no re-sync, and Mainnet Global Nodes have served GraphQL there too since September 28, 2026. Chainstack’s GraphQL vs gRPC guide and JSON-RPC migration doc cover the porting side.

What running your own actually costs

There is no published self-hosting cost figure for Sui that we could find, so we will not invent one. What can be described is where the cost comes from.

Initial sync. Syncing from genesis is off the table. You restore from a snapshot, and the time that takes depends on the snapshot type, the source and your network. Sui’s docs publish no expected restore duration. Restores also go wrong in practice: a GitHub issue from a user who could not initialize a mainnet node from a snapshot is one example of what operators report.

Storage growth and pruning. This is the Sui-specific trap. Pruning is controlled by two settings from Sui’s data management docs, num-epochs-to-retain for objects and num-epochs-to-retain-for-checkpoints for checkpoints:

Node roleObjectsCheckpoints
Validator or state-sync node02
RPC-serving node52
Full object historyu64::max2

Pruning takes effect over multiple days as RocksDB compaction completes, so a disk that looks fine on day one can fill up later. Sui’s docs do not publish a growth rate in GB per day, so size with headroom and watch it. Without pruning, 7 TB or more is realistic.

Updates. Sui releases move from devnet to testnet to mainnet. Recent mainnet tags, v1.79.1, v1.80.1 on September 23, v1.82.3 and v1.83.1 on November 4, point to a new release every few weeks. Mainnet moved to protocol version 141 on November 10, 2026, and the protocol upgrade takes effect at an epoch boundary once validators holding enough stake have upgraded. A node on an older binary can fall out of sync at that point, and the v1.82 JSON-RPC removal worked the same way: nodes below v1.82 stop when the network activates that protocol version. Upgrade timing is not optional.

Monitoring and reliability. The runbook lists the failure modes you will meet: config format changes after an upgrade, a node that falls behind after a restart (fix: restore from a snapshot), a full disk, a genesis mismatch, a blocked 8084/UDP port, and NOT_FOUND on pruned data. Watch highest_synced_checkpoint and last_executed_checkpoint against the chain tip, plus uptime, on the Prometheus port.

Hardware and hosting. Sui’s suggested server is 16 vCPUs, 128 GB of RAM and 4 TB or more of NVMe, which maps to a large cloud instance or a dedicated server. Chainstack lists infrastructure partners that offer servers meeting the Self-Hosted requirements, among them is*hosting, Vultr, Hostkey, Velia, Serverside and BreezeHost, on the system requirements page. Engineering time is the other cost, and it is real: indexing rollouts, upgrades and snapshot restores all need someone on call.

The “run it and forget it” myth. Your own node does not protect you from a network halt. Sui’s mainnet has stopped three times since late 2024:

DateWhat happenedDuration
November 21, 2024Congestion-control assertion crashed validators (postmortem)About 2.5 hours
January 14, 2026Validator consensus divergence; validators could not certify checkpoints (postmortem)About 6 hours
May 28 and 29, 2026Three halts tied to upgrade bugs in v1.72 (postmortem)About 15 hours 50 minutes in total

A node of your own protects you from your provider’s failure modes, and it lets you decide when to take an upgrade. Sui has needed emergency upgrades more than once, and an operator who cannot react quickly to one is exposed either way.

What changed: Chainstack Self-Hosted now supports Sui

Chainstack Self-Hosted now runs Sui Mainnet and Sui Testnet as deployment targets. They are available from the Control Panel with the same workflow as every other supported network: pick the network, pick a preset, deploy. The node is the official Sui full node, and initial sync is accelerated by a snapshot. Deployments can bootstrap from a snapshot or sync from genesis, chosen per deployment.

The preset sizing from the supported deployments catalog:

NetworkvCPURAMStorage
Sui Mainnet1664 GiB400 GB
Sui Testnet1664 GiB~2.2 TB

Mainnet bootstraps from a pruned snapshot, while Testnet bootstraps from a full snapshot and also ingests state from a checkpoint archive, which is why Testnet needs far more disk. Snapshot bootstrap temporarily needs about twice the steady-state storage while the archive is downloaded and extracted, so provision the Mainnet volume for roughly 800 GB at the peak. The Control Panel needs its own resources on top of that: 5 to 8 cores, 6 to 16 GiB of RAM and 15 to 20 GB of storage.

Compared with other Self-Hosted presets, Sui is the heaviest on CPU and light on disk when pruned:

FamilyvCPURAMStorage
Bitcoin48 GiB100 GB to 1 TB
TRON4 to 816 to 32 GiB200 GB to 3 TB
Ethereum L1832 GiB250 GB to 2 TB
OP Stack (Base)6 to 1224 to 48 GiB100 GB to 3.5 TB
Sui1664 GiB400 GB to 2.2 TB
Solana8 to 1664 to 256 GiB~2.5 to 5 TB

The preset is smaller than Sui’s own suggested minimum of 128 GB of RAM and 4 TB of NVMe. Treat it as a starting point and size up if you expect heavy read traffic or a longer retention window. [OPEN: confirm with the Chainstack team which workloads the 64 GiB / 400 GB preset is validated for, and why it sits below Sui’s guidance.]

On the network side, Sui serves gRPC and JSON-RPC multiplexed on a single port, 9000/TCP, and the node overview in the Control Panel shows the gRPC endpoint. The P2P port (8084/UDP) and the validator network address (8080) are used internally and are not exposed.

A few Sui-specific caveats, stated plainly:

  • Retention. [OPEN: the pruning values (num-epochs-to-retain and num-epochs-to-retain-for-checkpoints) and the rpc.enable-indexing setting are not documented for the preset.] After you deploy, call LedgerService/GetServiceInfo over gRPC and read lowestAvailableCheckpoint to see how much history the node actually holds.
  • Client versions and upgrades. Kubernetes self-healing restarts a crashed pod and resumes from the persistent volume, but client versions are not updated automatically. The Control Panel notifies you when a newer client or Control Panel version is available, Self-Hosted releases ship refreshed Sui images (the August 31 and September 22 releases both did), and you apply client changes through the node’s configuration tab, where they are recorded as tracked revisions. Upgrading the Control Panel with cpctl upgrade restarts only the Control Panel pods and leaves running nodes untouched. With Sui’s release pace, plan the version bumps.
  • JSON-RPC. While the client is below v1.82, the node serves JSON-RPC and gRPC on one port. From v1.82 the full node serves gRPC only. That is a Sui change, not a Chainstack setting.
  • GraphQL is not part of the preset. GraphQL needs the general-purpose indexer and a Postgres-compatible database, which is a separate stack from the full node. Managed Mainnet Global Nodes serve it; Self-Hosted serves the full node’s own gRPC and JSON-RPC port. [OPEN: confirm, and whether GraphQL is on the roadmap.]
  • Failover to managed nodes is on the roadmap, not shipped. Support for multiple endpoints and load balancing across nodes is planned for a future release.
  • You still own the node. The data stays in your perimeter, and the snapshot discipline, upgrade timing and capacity planning stay with you.

When to self-host Sui, and when not to

Run your own Sui node if:

  • You run an exchange, custody service or payment product that reconciles against Sui and wants no shared rate limits.
  • You operate trading, liquidation or market-making infrastructure that needs checkpoint streaming and control over upgrade timing.
  • You build indexes or datasets and need your own retention window.
  • You make a high volume of requests every day and the public endpoint’s limit of about 100 requests per 30 seconds is not an option.
  • You have compliance or audit requirements that call for control of the infrastructure.

Reach for managed Chainstack instead if:

  • You are learning, prototyping or running a low-volume project. The free Developer plan on Chainstack covers that.
  • You need GraphQL on Mainnet, or history longer than a self-managed retention window. Global Nodes serve JSON-RPC, gRPC and GraphQL from one endpoint.
  • You want isolated capacity without running the node yourself. Dedicated Nodes are available on the Pro plan and above and are billed per node, not per request.

Until recently, the middle ground had no clean answer. Self-hosting meant building the Kubernetes layer, the snapshot restore and the monitoring yourself, and managed meant giving up control of the node. Self-Hosted puts the operational layer on top of infrastructure you own. If Sui data is load-bearing for your business, running your own node was always the right call, and the path to a deployed, monitored node is now shorter.

FAQ

How long does the initial Sui node sync take?

Sui’s docs tell you not to sync from genesis, so the realistic answer is a snapshot restore. Chainstack’s Self-Hosted docs describe snapshot bootstrap as taking minutes to hours, followed by catch-up to the chain head in the background. Sui itself publishes no expected restore time. [OPEN: typical Mainnet restore time on Self-Hosted, and whether the snapshot is a Mysten formal snapshot, a RocksDB snapshot or built by Chainstack.]

How much storage does a Sui full node need?

It depends on pruning. The Self-Hosted preset uses 400 GB for Mainnet and about 2.2 TB for Testnet, plus roughly double during snapshot bootstrap. Sui’s own suggested minimum is 4 TB of NVMe, and an unpruned node can fill 7 TB or more.

Does Self-Hosted serve GraphQL?

Not by default. The preset runs the full node, which serves gRPC and JSON-RPC on port 9000. GraphQL needs the general-purpose indexer and a Postgres-compatible database. Managed Mainnet Global Nodes serve GraphQL at /graphql on the same endpoint and token as the other APIs. [OPEN: confirm.]

Does JSON-RPC still work?

Not on a node running v1.82 or later. Sui removed JSON-RPC from the full node in v1.82, which Testnet activated on October 15, 2026. At the client versions currently listed for Self-Hosted (below v1.82), the node serves both JSON-RPC and gRPC on port 9000, and from v1.82 it serves gRPC only. On Chainstack’s managed endpoints, Testnet no longer serves JSON-RPC and Mainnet stops when it upgrades to v1.82. Port your calls to gRPC, and to GraphQL on Mainnet, with the migration doc.

Why does my gRPC call return NOT_FOUND?

Full-node gRPC serves only data inside the node’s retention window. If the data has been pruned, the node returns NOT_FOUND, and there is no implicit fallback to an archive. Raise the retention settings or get that history from an archival source.

What happens at a Sui protocol upgrade?

The protocol version changes at an epoch boundary once enough stake has upgraded. A node that runs an older binary can fall out of sync, so plan version bumps before the activation. The Control Panel notifies you when a newer client is available and Self-Hosted releases ship refreshed Sui images, but you apply them. Mainnet moved to protocol version 141 on November 10, 2026. [OPEN: confirm that the Self-Hosted preset supports protocol 141.]

Is Sui Testnet supported?

Yes. Sui Mainnet and Sui Testnet are both available on Self-Hosted. Testnet needs about 2.2 TB because it bootstraps from a full snapshot and ingests state from a checkpoint archive.

What happens if my self-hosted Sui node fails?

Kubernetes restarts a failed pod, and if the data on the persistent volume is intact, the node resumes from its last state. A node that falls far behind after a restart may need a snapshot restore. Failover to a managed Chainstack node is on the roadmap but not shipped, so plan a fallback endpoint on your side.

Read more

SHARE THIS ARTICLE
Customer Stories

Cyvers

Cyvers hit 335% ROI on infrastructure with Chainstack Archive Nodes and Debug & Trace.

Unicrypt

Eliminating block synchronization issues with smooth network performance and affordable pricing.

Nexo

Nexo slashed Web3 infrastructure costs by a 5x margin using an Elastic Business data profile on Chainstack.