How long do Sui transactions take to finalize?

A Sui transaction is usually final in well under a second. Sui's docs put end-to-end finality at typically 400–700 ms, measured from when the user submits the transaction until the full node holds certified effects. Once a transaction is final it can't be reversed, and there are no block confirmations to wait for. The exact time depends on where you and your full node are relative to the validators.

What "final" means on Sui

A transaction moves from your client to a full node, then to a validator, through Mysticeti consensus, and finally to execution. The full node has settlement finality once it holds certified effects. Those come either from a quorum of validators that report the same effects digest, or from inclusion in a certified checkpoint. From then on the transaction is irreversible.

Mysten Labs measured end-to-end latency after rolling out Mysticeti v2 and the Transaction Driver (the default since node v1.60). Full nodes in Europe went from about 0.55 s to about 0.40 s, and full nodes in Asia from about 1.00 s to about 0.65 s.

Owned vs shared objects

Transactions that touch only owned objects (a plain SUI transfer, for example) can finalize on Mysticeti's fast path. They're certified by votes in the consensus DAG, without waiting for a full commit. The fast-path feature flag (mysticeti_fastpath) is enabled on mainnet in Sui's protocol config. Transactions that use shared objects have to be ordered by consensus first. A heavily contended shared object can add delay, and if one commit asks for too much execution on the same object, transactions can even be cancelled after consensus.

Things that add latency

Epoch changes. Roughly every 24 hours the network reconfigures, which adds a few hundred milliseconds to transactions submitted around that moment. See Sui epochs.
Geography. Every hop (client to full node, full node to validator) adds round-trip time.
Waiting for indexing. Execution results come back before the transaction is checkpointed and indexed. If you then read through an indexer or GraphQL, call waitForTransaction first.

Measure it yourself

TypeScript

import { SuiGrpcClient } from '@mysten/sui/grpc';
import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
import { Transaction } from '@mysten/sui/transactions';

const client = new SuiGrpcClient({
  network: 'testnet',
  baseUrl: 'https://fullnode.testnet.sui.io:443',
});
const signer = Ed25519Keypair.fromSecretKey(process.env.SUI_PRIVATE_KEY!);

const tx = new Transaction();
const [coin] = tx.splitCoins(tx.gas, [1]);
tx.transferObjects([coin], signer.toSuiAddress());

const start = performance.now();
const result = await client.signAndExecuteTransaction({ signer, transaction: tx });
console.log(result.$kind, `${Math.round(performance.now() - start)} ms`);

The timing includes building the transaction (gas price and coin lookups), so it overstates pure finality a little. Fund the address from the testnet faucet first, or try transactions in the playground.

Throughput vs latency

The Mysticeti paper reports about 0.5 s consensus commit latency and more than 200,000 TPS in benchmarks. Those are test conditions, not mainnet traffic. For a live number, look at how often checkpoints are produced. On 25 October 2026, mainnet produced checkpoints 338,000,000 to 338,005,000 in about 1,185 seconds, roughly one every 0.24 s.

Sources

Transaction life cycle, Sui documentation
Mysticeti v2, Sui blog
Consensus, Sui documentation
sui-protocol-config, MystenLabs/sui on GitHub