OnFinality
New RPC users get 35% off their first monthView the offer
RPC Assistant

Sui Docs: Where to Find SDK, Move, RPC, and Node References

Summary

# Sui Docs: Where to Find SDK, Move, RPC, and Node References

The official Sui documentation at docs.sui.io is the best starting point for building on Sui. It organizes material around getting started, Move development, onchain applications, the Sui stack, API and SDK references, node operation, and data management. The right path depends on whether you are learning the object model, deploying a package, querying data, or operating infrastructure.

For application development, begin with the official Sui TypeScript SDK documentation and the Move resources, then select an RPC API for network access. Sui's current tooling and API surface can change, so treat legacy JSON-RPC examples as version-sensitive and confirm supported methods in the current SDK and provider documentation. OnFinality can provide an RPC API or dedicated node infrastructure option when a project needs managed access or more control over its node environment.

This page maps the main Sui documentation paths to practical development decisions. It also shows how to validate an endpoint without assuming that a generic Ethereum JSON-RPC workflow applies to Sui.

Key Takeaways

  • Use docs.sui.io as the primary source for current Sui development, API, and node-operation documentation.
  • Follow the Move and object-model material before designing transaction and package workflows.
  • Use the Sui TypeScript SDK for client-side queries, transaction construction, signing, and related utilities.
  • Treat older JSON-RPC examples as version-sensitive and verify current API support before implementation.
  • Choose a managed RPC API for application access or evaluate a dedicated node when operational control and isolation are requirements.
  • Test reads, transaction submission, error handling, and network identity separately before production rollout.

Start with the documentation path that matches your task

The Sui documentation is broad enough that searching for one isolated RPC example can lead to the wrong starting point. Use the task map below first, then move into the relevant reference. The official documentation is the authority for protocol behavior, CLI commands, Move framework details, and current SDK guidance.

The Sui TypeScript SDK documentation is especially useful for application developers. It covers installation, modular packages, network locations, clients, keypairs, transactions, and faucet-related utilities. The SDK is not a replacement for understanding Sui's object model: transaction design, ownership, shared objects, and programmable transactions still require the conceptual documentation.

For infrastructure teams, the node-operator and data-management sections are more relevant than application tutorials. They cover the responsibilities and components involved in running a Sui full node, while an RPC provider can remove some of the operational work from an application team.

  • Learning Sui or Move: begin with Getting Started, Move, and object-model material.
  • Building a TypeScript application: use the current Sui TypeScript SDK and its client reference.
  • Deploying a package: follow package, environment, gas, publishing, and upgrade documentation together.
  • Querying or indexing data: read the API reference, then assess whether ordinary RPC reads are sufficient for the required history and volume.
  • Operating infrastructure: use the full-node, validator, and data-management documentation rather than application-only examples.
CriterionWhat to checkWhy it matters
Primary taskStart hereIt avoids mixing application, protocol, and node-operation instructions
Move package developmentMove language, package, object, and transaction documentationSui's object-centric execution model affects package and transaction design
Client integrationCurrent TypeScript SDK client and transaction referencesThe SDK abstracts request construction and provides Sui-specific utilities
RPC or node accessCurrent API reference and provider or full-node documentationEndpoint availability and method support can differ by API generation and provider

Decision guide: managed RPC, dedicated node, or self-operated node?

Choose a managed RPC API when the immediate requirement is application connectivity: reading objects, inspecting transactions, submitting signed transactions, or supporting a service without taking on node deployment and maintenance. Confirm the methods, data retention, authentication model, request policies, and supported transports before implementation.

A dedicated node is a different choice from a higher request allowance alone. It can be relevant when a workload needs a separately managed environment, predictable ownership of configuration, isolation from unrelated tenants, or a path toward specialized data services. Those requirements should be written down and validated with the infrastructure provider.

Run your own full node when protocol participation, local data control, custom integrations, or operational independence justify the cost of storage, upgrades, monitoring, synchronization, and incident response. The official Sui node documentation should be the source for resource and version requirements; do not infer them from another chain's node architecture.

  • Use an RPC API for the shortest path from an application to Sui network data.
  • Evaluate a dedicated node when workload isolation or infrastructure ownership is more important than the simplest setup.
  • Choose self-operated infrastructure only after accounting for synchronization, storage, upgrades, security, and on-call responsibilities.
  • Keep a provider abstraction in the application so endpoint changes do not require rewriting transaction logic.
CriterionWhat to checkWhy it matters
Managed RPC APISupported methods, authentication, request policies, data scope, and transportBest fit for teams that need network access without operating a node
Dedicated node infrastructureIsolation, configuration ownership, support boundary, and data requirementsUseful when a shared service does not match the workload's operational constraints
Self-operated full nodeHardware, storage, upgrades, monitoring, backups, and incident proceduresProvides more control but transfers ongoing operational responsibility to your team

Sui SDK and RPC concepts developers should separate

The Sui TypeScript SDK is a client library, not the network itself. It helps applications construct requests, work with Sui data types, build transactions, and interact with a configured network location. The RPC service behind the client still determines which API methods, limits, historical data, and submission behavior are available.

Sui examples should not be copied from an Ethereum tutorial without checking the model and API. Sui uses Move and an object-oriented asset model, and its transaction workflow has Sui-specific concepts such as object inputs, gas objects, programmable transaction blocks, and package publishing. A request that is syntactically valid in another ecosystem may be conceptually wrong for Sui.

The current SDK documentation lists network locations and example client setup. In production, replace development configuration with the endpoint and credentials supplied by the selected RPC provider, and keep secrets outside source control.

  • Pin compatible SDK versions and review release notes before upgrading.
  • Keep network selection explicit in configuration rather than hard-coding it in business logic.
  • Separate read clients from transaction-signing code where possible.
  • Treat private keys, API tokens, and signing material as separate secrets with different access controls.
CriterionWhat to checkWhy it matters
SDK responsibilityClient construction, serialization, transaction building, and signing helpersThese are application concerns implemented by the library
RPC responsibilityRequest handling, method support, access control, and data availabilityThe endpoint is the external dependency your application must monitor
Application responsibilityRetries, idempotency, error classification, key security, and observabilityProvider access does not remove the need for safe application behavior

Endpoint configuration without assuming a public URL

The OnFinality repository configuration for Sui does not provide a chainInfo.rpcUrls value. For that reason, this article does not publish a guessed public endpoint. Use the current Sui network page or your OnFinality account to obtain the applicable RPC URL and credentials, then inject them through environment variables.

A placeholder-free configuration pattern should still make the required boundary clear. The endpoint belongs in deployment configuration, while the SDK client remains responsible for Sui-specific requests. The exact client constructor and supported methods should follow the current version of the official SDK documentation.

  • Store the RPC URL in a secret or deployment environment variable rather than committing it to the repository.
  • Confirm that the endpoint targets Sui Mainnet when deploying production traffic; do not reuse testnet configuration.
  • Record the SDK version, provider endpoint, and network environment together for reproducible releases.
  • Add a startup check that verifies network identity before accepting application traffic.
CriterionWhat to checkWhy it matters
Endpoint sourceCurrent OnFinality Sui service configuration or account dashboardAvoids relying on stale or unofficial URLs
Environment selectionMainnet, testnet, local network, or another explicitly supported environmentAddresses and data are not interchangeable across environments
CredentialsAuthentication format and secret storage policyIncorrect headers or exposed tokens can block requests or create security risk

A reproducible Sui RPC validation workflow

Validate connectivity before debugging application logic. Start with a low-cost read supported by the provider, confirm the response format, and then test a representative object or transaction query. Do not treat a successful HTTP response as proof that every Sui method or historical query is available.

For a transaction workflow, test simulation or inspection where supported, signing, submission, and later status retrieval as separate steps. Record request IDs and classify failures by authentication, transport, method support, input validation, rate policy, or network state. This makes provider changes and SDK upgrades easier to diagnose.

A practical monitoring probe should use a known-safe read and alert on both transport failure and unexpected response shape. Avoid making a faucet request, publishing a package, or submitting a transaction as a health check.

  • Check DNS and TLS connectivity from the same region or runtime used by the application.
  • Verify authentication independently from payload validation.
  • Confirm the returned network identity and inspect the response schema.
  • Measure error rate and response time by method rather than using one aggregate number.
  • Use bounded retries with backoff and avoid retrying non-idempotent submission blindly.
  • Keep a second configured endpoint only when the application can safely handle differences in method support and data freshness.
CriterionWhat to checkWhy it matters
Failure symptom401, 403, or authentication-related responseThe request may not have reached method validation
Failure symptomMethod-not-found or legacy API errorThe example may target an older Sui API or an unsupported provider method
Failure symptomInvalid object, transaction, or argument errorThe endpoint may be working while the Sui-specific payload is incorrect
Failure symptomTimeout, gateway error, or intermittent transport failureInvestigate network path, request size, retry behavior, and provider status separately

Documentation maintenance and production handoff

Sui documentation is version-sensitive. Before a release, check the official docs, SDK package documentation, repository release notes, and the selected provider's method reference. Pay particular attention to changes involving API deprecation, transaction formats, package upgrades, and node configuration.

Keep an internal runbook with the network name, endpoint source, SDK version, supported methods, retry policy, escalation path, and rollback procedure. Link to the canonical OnFinality RPC pricing and supported RPC networks pages when evaluating commercial or multi-network expansion.

If the application grows from simple reads into indexing, analytics, or high-volume transaction workflows, reassess the architecture instead of assuming that an ordinary RPC connection is a complete data pipeline. A managed RPC API, dedicated node infrastructure, and a specialized indexing layer solve different problems.

  • Revalidate endpoint and method assumptions after SDK or protocol upgrades.
  • Document whether the workload needs current state, historical data, subscriptions, traces, or indexing.
  • Set an owner for provider configuration and a separate owner for signing security.
  • Review cost and operational tradeoffs before adding more endpoints or dedicated infrastructure.
  • Use the official Sui documentation for protocol facts and provider documentation for service-specific behavior.
CriterionWhat to checkWhy it matters
Current-state applicationRPC reads, transaction submission, and basic observabilityA managed API may cover the initial integration
Data-heavy applicationHistory, pagination, indexing, and retention requirementsRPC access alone may not provide the desired query model
Infrastructure buyerIsolation, support boundary, failover design, and total operating workThe cheapest endpoint is not necessarily the simplest operational choice

Frequently Asked Questions

Where are the official Sui docs?

The primary documentation is available at docs.sui.io. It includes getting-started material, Move and application development, SDK and API references, Sui Stack components, full-node operation, and data-management guidance.

Which Sui docs should I read first as a TypeScript developer?

Start with the official Sui TypeScript SDK documentation and its installation, client, network-location, transaction, and keypair sections. Read the Sui object model and transaction concepts alongside the SDK examples so that the code matches Sui's execution model.

Does Sui use the same JSON-RPC workflow as Ethereum?

No. Sui has its own data model, Move-based programming environment, transaction structures, and API conventions. Older JSON-RPC examples may also be version-sensitive, so verify current method support in the official SDK and provider documentation.

Should I run a Sui full node or use an RPC provider?

Use a managed RPC API when your main requirement is application access and you do not want to operate node infrastructure. Consider a dedicated node or self-operated full node when isolation, configuration control, local data, or operational independence justify additional responsibility.

How do I get a Sui RPC endpoint from OnFinality?

Start from the OnFinality Sui network page or your account configuration to obtain the current endpoint and authentication details. The endpoint should be injected through deployment configuration, not copied from an unverified public example.

RPC Knowledge Base

Related RPC details

Never Worry about Infrastructure Again

OnFinality takes away the heavy lifting of DevOps so you can build smarter and faster.

Get Started