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.
| Criterion | What to check | Why it matters |
|---|---|---|
| Primary task | Start here | It avoids mixing application, protocol, and node-operation instructions |
| Move package development | Move language, package, object, and transaction documentation | Sui's object-centric execution model affects package and transaction design |
| Client integration | Current TypeScript SDK client and transaction references | The SDK abstracts request construction and provides Sui-specific utilities |
| RPC or node access | Current API reference and provider or full-node documentation | Endpoint 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.
| Criterion | What to check | Why it matters |
|---|---|---|
| Managed RPC API | Supported methods, authentication, request policies, data scope, and transport | Best fit for teams that need network access without operating a node |
| Dedicated node infrastructure | Isolation, configuration ownership, support boundary, and data requirements | Useful when a shared service does not match the workload's operational constraints |
| Self-operated full node | Hardware, storage, upgrades, monitoring, backups, and incident procedures | Provides 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.
| Criterion | What to check | Why it matters |
|---|---|---|
| SDK responsibility | Client construction, serialization, transaction building, and signing helpers | These are application concerns implemented by the library |
| RPC responsibility | Request handling, method support, access control, and data availability | The endpoint is the external dependency your application must monitor |
| Application responsibility | Retries, idempotency, error classification, key security, and observability | Provider 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.
| Criterion | What to check | Why it matters |
|---|---|---|
| Endpoint source | Current OnFinality Sui service configuration or account dashboard | Avoids relying on stale or unofficial URLs |
| Environment selection | Mainnet, testnet, local network, or another explicitly supported environment | Addresses and data are not interchangeable across environments |
| Credentials | Authentication format and secret storage policy | Incorrect 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.
| Criterion | What to check | Why it matters |
|---|---|---|
| Failure symptom | 401, 403, or authentication-related response | The request may not have reached method validation |
| Failure symptom | Method-not-found or legacy API error | The example may target an older Sui API or an unsupported provider method |
| Failure symptom | Invalid object, transaction, or argument error | The endpoint may be working while the Sui-specific payload is incorrect |
| Failure symptom | Timeout, gateway error, or intermittent transport failure | Investigate 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.
| Criterion | What to check | Why it matters |
|---|---|---|
| Current-state application | RPC reads, transaction submission, and basic observability | A managed API may cover the initial integration |
| Data-heavy application | History, pagination, indexing, and retention requirements | RPC access alone may not provide the desired query model |
| Infrastructure buyer | Isolation, support boundary, failover design, and total operating work | The 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.