Ai Overview
Choosing among Sui node options is less about a single “best” setup and more about matching access, retention, and operational control to your app. A wallet, indexer, trading app, and internal analytics pipeline can all touch the same chain but need very different infrastructure. 375 per 1M compute units, and Nadcab Cloud starts from $10 with no rate tiers. Nadcab Cloud starts at $10 with no rate tiers: you pay $0.
Key Takeaways
- Sui node options should be chosen based on access patterns, retention needs, and operational ownership rather than defaulting to self-hosting.
- Pruning lowers storage burden but can permanently limit your ability to answer historical queries or run later backfills.
- Managed RPC is often enough for wallets, dashboards, and standard app backends that mainly need current-state reads and reliable transaction submission.
- Dedicated or self-managed Sui nodes make more sense when you need custom auth, stronger isolation, defined retention, or specialized ingestion pipelines.
- The safest path is to start with endpoint abstraction and observability so you can migrate from shared RPC to dedicated infrastructure without rewriting core app logic.
Choosing among Sui node options is less about a single “best” setup and more about matching access, retention, and operational control to your app. A wallet, indexer, trading app, and internal analytics pipeline can all touch the same chain but need very different infrastructure. On Sui, that decision often starts with a practical question: do you really need your own node, or is managed RPC enough?
The answer depends on how you read chain data, how much historical state you need, and how much downtime your team can absorb. Sui also introduces choices that many EVM-first teams do not expect, including different access methods and the impact of pruning on what a node can answer over time.
This guide breaks down Sui access patterns in plain engineering terms. It covers gRPC, provider abstractions, pruning tradeoffs, and a migration path from prototype to production. Where managed infrastructure is a fit, services like Nadcab RPC can reduce time-to-launch; where it is not, this article shows the signals that tell you it is time to move closer to dedicated or self-run infrastructure.
One API key. 70+ blockchains. Production-grade RPC.
Nadcab RPC gives you HTTPS and WebSocket endpoints across 150+ chain endpoints with smart routing and a 99.99% gateway uptime target. Pay as you go from $0.375 per 1M compute units.
Why Sui node choices are different from EVM RPC
Teams coming from Ethereum-style development often assume node planning is mostly about throughput and archive access. Sui changes that conversation. The data model, object-centric execution, and newer ecosystem tooling mean your application may depend on data access patterns that do not map cleanly to familiar JSON-RPC habits.
That matters because the phrase “run a node” can mean different things in practice. One team may only need a reliable endpoint to submit transactions and fetch recent objects. Another may need long-range historical queries, event backfills, or a custom ingestion pipeline for analytics. Those are different operational problems.
If your app mainly signs and submits transactions, reads current balances, and powers standard frontend interactions, a managed endpoint is often enough. If you are building a data-heavy service, you should treat node choice as part of product architecture, not just DevOps. For background on how RPC layers fit into broader web3 stacks, Nadcab Labs has a useful primer on Web3 infrastructure explained: nodes, RPCs, and APIs.
What Sui teams usually optimize for
- Fast read access for wallets, dashboards, and app UIs
- Consistent transaction submission with predictable retry behavior
- Historical coverage for analytics, tax records, or compliance workflows
- Operational control over upgrades, retention, and failure domains
- Cost discipline during early growth
The important part is that these goals do not always point to the same infrastructure choice.
Sui access methods: gRPC, GraphQL, and provider abstractions
Sui developers are not limited to a single access pattern. In practice, teams usually choose between direct protocol-native interfaces, higher-level query layers, or managed provider abstractions that simplify common app traffic.
gRPC
gRPC is typically the most direct path when you need low-level access and tighter control over how your service consumes chain data. It fits backend systems that stream data, maintain internal state, or need structured service-to-service communication.
The tradeoff is complexity. You own more of the client behavior, schema handling, deployment process, and compatibility testing. That can be worth it for internal systems, but it is often overkill for product teams still validating user demand.
GraphQL and query-oriented access
GraphQL-style access can be useful when you want flexible reads without stitching together multiple lower-level calls. It is often easier for frontend-heavy workloads and internal dashboards. But teams should still evaluate query cost, caching strategy, and whether the endpoint exposes everything their app will eventually require.
Provider abstractions
Many production apps start with managed RPC because it is the fastest way to get stable network access into code. A multi-chain gateway such as Nadcab RPC gives teams one API key across supported networks, including Sui, with a consistent endpoint format and both HTTPS and WebSocket access where applicable.
For Sui, the Nadcab RPC endpoint format is straightforward:
https://rpc.nadcab.com/sui/<your-api-key>
This is especially useful for teams shipping cross-chain products that already touch EVM and non-EVM networks. Instead of building different auth and endpoint conventions for each chain, developers can standardize environment configuration early. You can review the full supported list on the Nadcab RPC chainlist.
A simple Node.js example
The exact Sui client library you use may vary by SDK version, but the pattern is the same: keep the endpoint in configuration and avoid hard-coding infrastructure assumptions into business logic.
const SUI_RPC_URL = "https://rpc.nadcab.com/sui/<your-api-key>";
async function getLatestCheckpoint() {
const response = await fetch(SUI_RPC_URL, {
method: "POST",
headers: {
"content-type": "application/json"
},
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "sui_getLatestCheckpointSequenceNumber",
params: []
})
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
const data = await response.json();
if (data.error) {
throw new Error(data.error.message || "RPC error");
}
return data.result;
}
getLatestCheckpoint()
.then((checkpoint) => {
console.log("Latest checkpoint:", checkpoint);
})
.catch((err) => {
console.error("Request failed:", err.message);
});
If you need implementation guidance for transaction building patterns on Sui, see Nadcab Labs’ Sui PTB RPC guide for developers.
Pruning explained: what data you keep and what you lose
Pruning is one of the most important factors in Sui node planning. In simple terms, pruning removes older data that a node no longer needs to keep for its primary role. That reduces storage and operational burden, but it also limits what the node can answer later.
For many apps, pruning is not a problem. If your frontend only needs current balances, recent transactions, and fresh object state, a pruned node or a managed endpoint backed by practical retention choices may be fine.
It becomes a problem when your business depends on the past.
Common cases where pruning hurts
- Historical analytics that must replay older chain activity
- Internal audit pipelines that need reproducible past state
- Compliance or reporting workflows that cannot tolerate gaps
- Backfills for newly launched product features
- Recovery after downstream data corruption
If a node has pruned data you later need, no retry policy can bring that history back. You will need another source of truth, such as archive-oriented infrastructure, a dedicated data pipeline, or an external warehouse you maintained from day one.
Questions to ask before accepting pruning
- Do we need to reconstruct user activity from months ago?
- Can our analytics tolerate missing older objects or events?
- Are we building an app, or are we also building a data product?
- Do we have a separate ingestion pipeline that stores what we care about?
This is why infrastructure decisions should be made alongside data retention policy, not after launch.
Connect to Sui in one line
Swap your current endpoint for Nadcab RPC and keep your existing ethers, viem, web3.js or Solana code:
https://rpc.nadcab.com/sui/<your-api-key>
When managed RPC is enough for Sui apps
Managed RPC is usually enough when your main requirement is dependable chain access rather than deep infrastructure customization. That includes many wallets, consumer dApps, admin dashboards, and early-stage products.
Good fit scenarios
- Submitting transactions from a backend or relayer
- Reading balances, owned objects, or recent chain state
- Powering UI queries for a web or mobile app
- Running staging and production environments with separate keys
- Launching quickly without node operations staff
In these cases, a managed gateway removes several tasks at once: node deployment, patching, failover design, and endpoint standardization. Nadcab Cloud is built for this shared, auto-scaling model, and Nadcab states a 99.99% gateway uptime target with a live status page. Those details matter when your app team wants a clear operating boundary between product code and chain infrastructure.
Managed RPC is also attractive if you are building beyond Sui. Nadcab RPC supports 70+ networks and 150+ endpoints with one API key, which helps teams unify environment management across multiple chains without changing providers every time a new market matters.
When teams should move to dedicated or self-managed Sui nodes
There is a point where shared endpoints stop being the right abstraction. The trigger is usually not traffic alone. More often, it is the combination of criticality, retention, custom policy, and the need to control failure behavior.
Move toward dedicated infrastructure when:
- You need predictable resource isolation. Shared infrastructure is efficient, but dedicated capacity gives clearer control over noisy-neighbor risk and tuning.
- You need custom auth or logging. Enterprise security and compliance requirements often demand network-specific controls and detailed request records.
- You need your own retention policy. If historical data is product-critical, you may want infrastructure you operate or contractually define.
- You need custom routing or hybrid ownership. Some teams want their own nodes behind a managed routing layer.
This is where product lines matter. Nadcab Core is the model for teams that want their own nodes combined with Nadcab’s routing engine. Nadcab Craft is the dedicated-cluster option for custom auth, compliance logging, and enterprise SLA needs. Neither replaces engineering judgment, but both represent cleaner migration steps than a full jump from shared endpoint to fully self-run fleet.
Self-managed nodes still make sense for teams with strong platform engineering, strict internal controls, or highly specialized data ingestion paths. Just be honest about the burden: upgrades, storage planning, incident response, monitoring, backups, and on-call rotations all become your problem.
Pick the RPC setup that fits your stage
- Nadcab Cloud: shared, auto-scaling endpoints for dApps and wallets
- Nadcab Core: bring your own nodes and add our smart routing engine
- Nadcab Craft: dedicated clusters, custom auth, compliance logging and enterprise SLA
- Nadcab for Chains: RPC infrastructure for new L1 and L2 networks
How to evaluate latency, reliability, and failure handling
Marketing pages often compress infrastructure quality into a single uptime number. That is not enough for engineering decisions. You should evaluate how an endpoint behaves under ordinary failure, not just under happy-path load tests.
Checklist for real evaluation
| Area | What to test | Why it matters |
|---|---|---|
| Latency | Measure p50 and tail latency from the same region as your app servers | User experience is shaped by slow outliers, not just average requests |
| Reliability | Test across several days and deployment windows | Short tests miss maintenance events and route instability |
| Error handling | Inspect HTTP errors, RPC errors, and timeout patterns | You need retry logic that matches actual failure modes |
| Consistency | Compare responses for recent chain state across repeated reads | Important for wallets, confirmations, and app trust |
| Status visibility | Check whether a public status page exists | Helps operators distinguish provider issues from app bugs |
| Migration risk | Swap endpoints in staging without code rewrites | Clean abstraction lowers switching and scaling risk |
Build clients for failure
No RPC path is perfect. Your client should classify errors into categories: retryable, non-retryable, and operator-visible. Timeouts, transient upstream issues, and rate or capacity signals should be handled differently from invalid transaction payloads or malformed parameters.
Nadcab Labs covers practical setup patterns in this Web3 API integration guide, including authentication and error-handling ideas that apply directly to RPC clients.
Cost and ops tradeoffs: shared endpoints vs owned infrastructure
Cost discussions often go wrong because teams compare only invoice totals. The real comparison is invoice plus operating burden plus business risk.
With shared RPC, the direct cost is easier to estimate. Nadcab RPC uses pay-as-you-go pricing at $0.375 per 1M compute units, and Nadcab Cloud starts from $10 with no rate tiers. That simplicity helps founders model early-stage usage without negotiating custom infrastructure too early.
Owned infrastructure has different economics. You may reduce per-request dependency on a shared gateway, but you take on hidden work: provisioning, failover architecture, observability, upgrades, security hardening, and staff time. Those costs are often acceptable for mature teams and wasteful for small product squads.
Decision table
| Option | Best for | Main upside | Main tradeoff |
|---|---|---|---|
| Shared managed RPC | Prototypes, wallets, standard app backends | Fast launch, low ops overhead | Less control over low-level behavior |
| Dedicated managed infrastructure | Growing production apps with stricter requirements | More isolation and policy control | Higher commitment than shared endpoints |
| Self-managed nodes | Teams with custom data and platform needs | Maximum control | Highest operational burden |
For a broader framework on how infrastructure vendors fit into dApp stacks, see Nadcab Labs’ article on node infrastructure for dApps and RPC providers.
Stop overpaying for RPC requests
Nadcab Cloud starts at $10 with no rate tiers: you pay $0.375 per 1M compute units and scale up or down without contracts. Every plan includes archive and WebSocket access on supported networks.
A migration path from prototype to production on Sui
The best infrastructure plan is usually evolutionary. Most teams should not start by running everything themselves. They should start with clean abstractions that let them change later without rewriting application logic.
Stage 1: Prototype
Use a managed endpoint, store the RPC URL in environment configuration, and keep chain access behind a small internal client layer. Do not let UI code, workers, and backend services all implement their own ad hoc request logic.
Example environment variable:
SUI_RPC_URL=https://rpc.nadcab.com/sui/<your-api-key>
Stage 2: Early production
Add observability around request latency, error classes, and transaction confirmation flow. Keep an application-side cache for hot reads. Start exporting chain data you may need later, even if today’s product does not expose historical views.
Stage 3: Growth
Split workloads by purpose. Keep transaction submission and user-facing reads on the most reliable path. Move analytics, backfills, and heavy internal queries onto dedicated infrastructure or separate ingestion pipelines so they do not compete with user traffic.
Stage 4: Mature production
Choose dedicated managed infrastructure or self-run nodes if business requirements justify them. At this stage, your decision should be driven by policy, data retention, and recovery objectives, not by habit.
If your product roadmap includes launching infrastructure for your own chain or rollup ecosystem later, it is also worth understanding services such as Nadcab for Chains, which is designed for new L1 and L2 RPC operations.
For teams that need implementation help beyond infrastructure selection, Nadcab also offers Web3 development services and a blockchain development company practice that can support architecture and delivery.
Related guides from Nadcab Labs
Final Thoughts
Sui node planning is really about choosing the right level of ownership for your app’s access and data needs. If you mainly need reliable transaction submission and current-state reads, managed RPC is often enough. If your product depends on custom retention, internal compliance, or large-scale historical ingestion, dedicated or self-managed infrastructure becomes more compelling.
The key is to decide early what data you must preserve, what failures you can tolerate, and how much operational complexity your team can realistically carry. Start simple, abstract your endpoint usage, and design for migration. That approach lets you use shared infrastructure like Nadcab RPC where it makes sense today while preserving a clean path to more specialized Sui node options later.
Ship faster on infrastructure you don’t have to babysit
Get one API key for 70+ networks, HTTPS and WebSocket endpoints, smart routing and a live status page. Building something bigger? Our blockchain team can design and run the full stack with you.
Get Your Free API Key →Talk to Our Experts
Pay as you go · No rate tiers · 99.99% gateway uptime target
Frequently Asked Questions
Q1.Do I need to run my own Sui node for a production app?
Not always. Many production Sui apps can run well on managed RPC if they mostly submit transactions and read recent state. You should consider your own node or dedicated infrastructure when you need custom retention, stronger isolation, internal compliance controls, or large-scale historical ingestion that shared endpoints may not be designed to serve.
Q2.What does pruning mean on a Sui node?
Pruning means the node removes older data it no longer keeps locally. That helps reduce storage and operational overhead, but it also limits what the node can answer later. If your app needs historical analytics, audits, or backfills, pruning can become a serious limitation unless you store that history elsewhere.
Q3.Is gRPC better than RPC for Sui development?
It depends on your workload. gRPC is often better for backend systems that need structured service communication, streaming, or lower-level control. Managed RPC is usually simpler for frontend apps, wallets, and standard transaction workflows. Many teams use RPC first, then add lower-level access paths only when data or performance needs justify the extra complexity.
Q4.When should a team move from shared Sui RPC to dedicated infrastructure?
Move when infrastructure requirements become product requirements. Common signals include needing resource isolation, custom authentication, compliance logging, guaranteed retention strategy, or cleaner separation between user traffic and heavy internal jobs like analytics and backfills. The shift is usually driven by reliability and control needs more than by raw request volume alone.
Q5.How should I evaluate a Sui RPC endpoint before launch?
Test from the same region as your app, and measure both normal latency and slow outliers. Inspect timeout behavior, error formats, recent-state consistency, and how easy it is to switch endpoints in staging. Also check whether the provider offers visibility such as documentation, status reporting, and a clear endpoint structure for production operations.
Explore Services
Related Services
Reviewed by

Aman Vaths
Founder of Nadcab Labs
Aman Vaths is the Founder & CTO of Nadcab Labs, a global digital engineering company delivering enterprise-grade solutions across AI, Web3, Blockchain, Big Data, Cloud, Cybersecurity, and Modern Application Development. With deep technical leadership and product innovation experience, Aman has positioned Nadcab Labs as one of the most advanced engineering companies driving the next era of intelligent, secure, and scalable software systems. Under his leadership, Nadcab Labs has built 2,000+ global projects across sectors including fintech, banking, healthcare, real estate, logistics, gaming, manufacturing, and next-generation DePIN networks. Aman’s strength lies in architecting high-performance systems, end-to-end platform engineering, and designing enterprise solutions that operate at global scale.




