To benchmark Sui’s transaction throughput, use the Sui SDK to submit a high volume of transactions with varying object dependencies. Focus on independent, owned-object operations to maximize parallel execution. Use programmable transaction blocks (PTBs) to batch multiple operations and measure transactions per second (TPS) over a fixed duration. Monitor results via sui_getTransactionBlocks and analyze end-to-end latency. Ensure your workload avoids shared object contention, which limits parallelism. For accuracy, run tests against a dedicated testnet RPC endpoint and aggregate data across multiple runs.

To benchmark Sui’s transaction throughput effectively and validate its performance claims, there are several tools, techniques, and methodologies you can use. Testing on Sui Testnet can help you measure how well the network handles various types of transactions, and ensure that the system behaves as expected under load. Here's a structured approach to benchmark Sui’s transaction throughput:

1. Define Key Metrics to Measure

Before you start, define what specific metrics you want to measure. Common benchmarks for transaction throughput include:

• Transactions per second (TPS): This is the primary metric to measure the throughput of the network.
• Latency (transaction confirmation time): The time it takes for a transaction to be processed and confirmed by the network.
• Gas consumption: Measure the gas cost per transaction and how that varies with different transaction types.

2. Use Sui’s Built-in Benchmarking Tools

Sui provides a few ways to benchmark and measure performance:

a) Sui Client CLI

The Sui CLI (sui client) can be used to interact with the Testnet and can also be used to simulate transactions. By using the simulate-transaction command, you can gauge the expected gas cost and latency of transactions.

Example:

sui client simulate-transaction --gas-budget 10000 --transaction <transaction_file>

This will give you an estimate of gas and help you measure the time it takes to simulate transactions on the Testnet.

b) Sui Benchmarking Scripts (Custom Scripts)

You can write benchmarking scripts using Sui's SDK (in TypeScript, Python, or other supported languages). These scripts can simulate and send transactions at a specified rate to the Testnet, allowing you to measure throughput.

Example:

const { SuiClient, TransactionBlock } = require('@mysten/sui.js');

const client = new SuiClient({ rpcUrl: "https://testnet.sui.io/rpc" });

async function benchmarkTransactions(numTransactions: number) {
  const startTime = Date.now();
  
  for (let i = 0; i < numTransactions; i++) {
    const txn = new TransactionBlock();
    // Add the move call or transaction logic
    await client.submitTransaction(txn);
  }
  
  const endTime = Date.now();
  console.log(`Processed ${numTransactions} transactions in ${endTime - startTime}ms`);
}

benchmarkTransactions(1000);  // Benchmark 1000 transactions

This script would help you track how many transactions can be processed within a given timeframe and calculate the TPS.

3. Use Stress Test Tools

For more extensive testing and to simulate high loads, you can use stress testing tools to push large volumes of transactions to the Testnet:

a) Artillery or JMeter

• These are load testing tools that can be configured to send a high volume of transactions (or requests) to Sui’s Testnet.
• With Artillery, for example, you can create scenarios that mimic real-world user behavior and send large amounts of API requests to your Sui RPC endpoint to measure response times and throughput.

Example with Artillery:

config:
  target: 'https://testnet.sui.io/rpc'
  phases:
    - duration: 60
      arrivalRate: 100  # 100 requests per second
scenarios:
  - flow:
      - post:
          url: "/submit_transaction"
          json:
            transaction: "your_transaction_data_here"

This setup will simulate 100 requests per second to the Sui Testnet for 60 seconds and measure the TPS and latency.

b) Locust

Locust is another load testing tool that is highly configurable. You can create load test scenarios by defining the behavior of simulated users, specifying the rate of requests, and measuring throughput.

Example with Locust:

from locust import HttpUser, task, between

class SuiTestUser(HttpUser):
    wait_time = between(1, 2)

    @task
    def send_transaction(self):
        self.client.post("/submit_transaction", json={"transaction": "your_transaction_data_here"})

This can simulate a large number of concurrent users and help you measure the performance under load.

4. Monitor Node Performance and Resource Usage

• CPU, Memory, Disk: Measure how much CPU, memory, and disk are being used on the nodes during heavy transaction loads.
• Network Latency: Monitor network latency, especially between validator nodes and RPC endpoints, as high latency can affect throughput.
• Sui's Built-in Metrics: Monitor Sui's built-in metrics like the number of successful transactions, failed transactions, and gas usage using prometheus or similar monitoring tools.

5. Benchmark with Multiple Fee Tiers

Sui supports multiple fee tiers. It's important to benchmark transactions across different fee tiers to see how fee structures affect throughput.

• Test transactions across low, medium, and high fee tiers to see if the gas fee influences transaction processing speed.
• Experiment with different gas budgets to optimize for performance while keeping gas costs reasonable.

6. Check for Latency and Block Times

Another metric to measure is latency and block times for transactions. High throughput doesn’t necessarily mean low latency, so monitor:

• Time to finality: How long does it take for a transaction to be fully confirmed and added to the ledger?
• Block time consistency: Is block production consistent, or do delays occur under high load?

7. Use Sui Explorer for Monitoring

• Sui Explorer and other blockchain explorers can help you see the throughput in terms of transactions per block and provide insight into transaction confirmation times.

8. Analyzing Results and Benchmark Comparisons

After conducting the tests:

• Analyze the throughput (TPS): Compare how Sui performs under different loads. Look for patterns or bottlenecks where throughput drops significantly.
• Measure the latencies: See how long it takes for transactions to get processed and confirmed.
• Network/Node Impact: Ensure that performance is not being hindered by network congestion or node performance issues.

Summary of Methodology:

1. Use the Sui CLI to simulate transactions and gather gas estimates.
2. Stress test with tools like Artillery, JMeter, or Locust to measure TPS and latency.
3. Monitor resource usage on nodes during testing (CPU, memory, disk, network).
4. Test across multiple fee tiers to understand how gas structures affect throughput.
5. Use Sui Explorer and other monitoring tools to gather real-time data on throughput and performance.
6. Benchmark different gas budgets to optimize for speed and cost.

By combining these tools and methodologies, you can get a clear understanding of Sui’s transaction throughput on the Testnet and evaluate its performance under various loads and configurations.

Use Sui Benchmark Tools (sui-benchmark) or custom scripts to stress-test TPS.

1. Quick Test (CLI)

# Install sui-benchmark  
cargo install --git https://github.com/MystenLabs/sui sui-benchmark  

# Run load test (adjust --tx-count)  
sui-benchmark --testbed testnet --workload transfer-object --tx-count 1000

2. Custom TS Script

import { SuiClient } from '@mysten/sui.js/client';
const client = new SuiClient({ url: 'https://fullnode.testnet.sui.io' });

// Send parallel TXs
const txs = Array(100).fill(0).map(() => client.transferObject(...));
await Promise.all(txs); // Measure time vs success rate

Key Metrics

• TPS: Transactions per second (count committed TXs).
• Latency: Time to finality.
• Error Rate: Failed TXs.

To benchmark Sui's transaction throughput on the Testnet and assess its performance claims, you need to carefully design your testing approach and use the right tools to simulate realistic transaction loads. Below is a detailed methodology and recommended tools for benchmarking Sui's performance:

1. Define Benchmarking Objectives

• Transaction Throughput: Measure how many transactions per second (TPS) Sui can handle under various conditions.
• Latency: Measure the time it takes for a transaction to be processed and confirmed.
• Scalability: Test how Sui’s performance scales as the number of nodes, validators, and transaction volume increases.

2. Tools to Use

Here are some tools and methodologies for benchmarking transaction throughput:

Sui Client & RPC

• Sui CLI: Use the official Sui CLI to submit transactions, query block states, and measure transaction performance.

  • sui client can help measure the time taken to execute a transaction, which can help you assess the transaction throughput under different load conditions.

Load Testing Tools

• Locust (or other load-testing tools like Artillery, Gatling): These tools are excellent for simulating high loads and generating traffic to your Testnet. Locust allows you to define custom transaction scenarios and simulate multiple users sending transactions simultaneously.

  • You can write a Locust script that connects to the Sui Testnet RPC endpoint and sends transactions (e.g., creating or transferring objects) while measuring the time taken to process them.

  Example Locust script to benchmark:

  from locust import HttpUser, task, between
  
  class SuiBenchmark(HttpUser):
      wait_time = between(1, 3)  # Simulate user wait time between actions
  
      @task
      def send_transaction(self):
          response = self.client.post("/sui/transaction", json={
              # Your transaction payload here
          })
          assert response.status_code == 200
  

Custom Transaction Load

• Create a custom script to send Sui transactions in bulk through the RPC API. This can be a basic Python or Node.js script that interacts with the Sui Testnet and measures:

  • The time taken to send a batch of transactions.
  • The average latency and throughput as a function of load.

Example using Python and the requests library:

import time
import requests

def send_transaction():
    url = "https://rpc.sui.io"
    headers = {'Content-Type': 'application/json'}
    data = {
        "method": "sui_executeTransaction",
        "params": [transaction_data],  # Your transaction data here
    }
    response = requests.post(url, json=data, headers=headers)
    return response.status_code

def benchmark_transactions(n):
    start_time = time.time()
    for _ in range(n):
        send_transaction()
    end_time = time.time()
    print(f"Processed {n} transactions in {end_time - start_time} seconds")

benchmark_transactions(1000)  # Benchmark 1000 transactions

Benchmarking Tools Specific to Sui

• Sui Explorer: You can also use the Sui Explorer to manually monitor transactions, check block heights, and track transaction speeds during your benchmarking period.
• Sui Metrics: Sui may expose some metrics endpoints to monitor validator performance and system health. You can use these to measure the actual system throughput from the network’s perspective (e.g., average TPS over a period).

External Benchmarking Services

• If you need to benchmark against other blockchains or even compare Sui with other networks, services like Chainlink’s VRF (for randomness) or Lighthouse can provide cross-chain benchmarks.
• You can use DeFiLlama for comparative analysis between Sui and other blockchain projects if they publish performance data.

3. Benchmarking Methodology

Single-Transaction Throughput

• Test the time it takes for a single transaction to go through the entire network and be confirmed. Measure the latency and compare it across different transaction types (e.g., object creation vs. object transfer).

Batch Throughput (Multiple Transactions)

• To stress-test the network, send a batch of transactions in quick succession, and track the throughput (TPS). This will give you an idea of how Sui handles high-volume operations.

Concurrency and Load Testing

• Test how well Sui performs under varying loads by simulating multiple users or bots interacting with the network. Gradually increase the load and measure:

  • TPS as load increases.
  • Latency for individual transactions under load.

Simulate Real-World Transactions

• Benchmark with realistic transactions such as creating NFTs, transferring coins, and executing smart contract logic. This reflects the true performance of the network under diverse conditions.

Stress Test

• Test for extreme conditions (e.g., sending thousands of transactions in a short time) to see how Sui scales and identify any bottlenecks.

4. Key Metrics to Measure

• Transactions per Second (TPS): The number of successful transactions that the system processes per second.
• Latency: The time it takes for a transaction to be confirmed after submission. Measure both average and peak latency.
• Gas Usage: Track how much gas is used per transaction to understand how much it costs to execute different transaction types.
• Block Times: Measure the time it takes for blocks to be produced and transactions to be included in the block.

5. Analyzing and Interpreting Results

After running your tests:

• Plot TPS vs. Load: This helps visualize how Sui performs under increasing transaction loads.
• Latencies: Look for spikes in latency as the system is stressed. A sudden increase in latency could indicate a bottleneck in processing.
• Scaling Behavior: Evaluate if throughput improves as more resources (nodes/validators) are added to the network.

6. Other Considerations

• Network Latency: Ensure you’re testing from a server that is geographically close to the Sui Testnet to avoid external network latency.
• Validators: Consider how many active validators are participating in your test to assess how well the network scales with increasing nodes.

7. Common Pitfalls to Avoid

• Overloading RPC: Be mindful of rate limiting on the Testnet RPC. Avoid sending too many requests too quickly, as this could artificially affect your results.
• Testnet Instability: Keep in mind that Testnets are not always as stable as Mainnets, so any test results may be influenced by temporary network conditions.

Conclusion

To benchmark Sui's transaction throughput effectively, you need to simulate realistic loads using transaction batching, load testing tools, and the Sui RPC API. Measure key metrics like TPS, latency, and gas usage, and ensure to test under concurrent loads and stress conditions. The results will give you insights into Sui’s scalability, latency, and how it performs in different scenarios, allowing you to assess its true capabilities.

To benchmark Sui’s TPS (transactions per second):

1. Use Sui’s Benchmarking Tools – sui-benchmark for controlled load tests.
2. Deploy Custom Workloads – Simulate real-world transactions (transfers, smart contracts).
3. Monitor with Metrics – Track TPS, latency, and success rate via Prometheus/Grafana.
4. Testnet vs Local – Compare public Testnet vs a private local network for baseline.
5. Check Validator Load – High TPS depends on validator performance.

Tip: Review Sui’s docs for latest tools like sui-tps.

Use Sui's sui-benchmark tool with custom workloads on Testnet for accurate TPS measurement. Focus on parallelizable transactions and adjust submission rate to find saturation point.

Best Way to Benchmark Sui’s Transaction Throughput (Testnet/Mainnet)

1. Tools for Benchmarking

• Sui CLI + Scripts (Basic)

  # Generate 1000 simple transfer TXs
  for i in {1..1000}; do
    sui client transfer-sui --to 0xRECEIVER --amount 1 --gas-budget 5000000 &
  done
  

• TypeScript Load Tester (Advanced)

  import { SuiClient, TransactionBlock } from '@mysten/sui.js';
  
  const client = new SuiClient({ url: 'https://fullnode.testnet.sui.io' });
  const SENDER = '0xYOUR_WALLET';
  const RECEIVER = '0xTARGET';
  
  async function sendBatch(txCount: number) {
    const startTime = Date.now();
    const promises = Array(txCount).fill(0).map(() => {
      const tx = new TransactionBlock();
      tx.transferObjects([tx.gas], RECEIVER);
      return client.signAndExecuteTransactionBlock({ 
        transactionBlock: tx, 
        signer: SENDER_KEY 
      });
    });
    await Promise.all(promises);
    const tps = txCount / ((Date.now() - startTime) / 1000);
    console.log(`TPS: ${tps}`);
  }
  

• Sui Benchmarking Kit (SBK) (Official)

  git clone https://github.com/MystenLabs/sui-benchmark
  cd sui-benchmark
  cargo run -- --test-tps --tx-count 10000 --num-workers 16
  

2. Key Metrics to Track

1. Use the sui-benchmark tool, which is included in the Sui GitHub repo. It allows you to simulate thousands of transactions per second using multiple workers.

2. Clone the repo and run cargo run --release --bin sui-benchmark -- --help to explore benchmarking options like TPS rate, target objects, and thread count.

3. Spin up your own Sui local cluster (sui-test-validator) for controlled tests, or benchmark on Testnet, noting that public networks have variable load.

4. Choose what type of transaction to test: transfer_object, coin_split, or custom Move module functions. Each has a different gas profile and object handling complexity.

5. Generate a large batch of objects (or shared objects) and pre-fund test accounts to remove bottlenecks from coin availability.

6. Use --num-workers, --num-threads, and --target-tps flags to scale your test while tracking latency and throughput stats.

7. Enable metrics collection via Prometheus and Grafana to observe latency, success rate, and gas usage over time.

8. Run tests under different network and node conditions to understand the ceiling — localnet will show higher TPS than Testnet due to validator latency.

9. For comparison, benchmark simple versus complex transactions (e.g., basic transfers vs shared-object mutating calls) to see how transaction type impacts throughput.

10. Document gas consumption, error rates, and confirmed TPS (vs submitted TPS) to produce a comprehensive performance profile.

To benchmark Sui’s transaction throughput on Testnet, start by setting up a local validator or use the official Testnet with a controlled transaction environment. Use the sui-benchmark tool from the Sui GitHub repo, which is designed for simulating high-volume transactions with configurable parameters. You can also script transactions using the TypeScript or Rust SDKs to send batches of transactions in parallel and measure end-to-end performance. Monitor metrics like TPS (transactions per second), latency, and success rate using Prometheus and Grafana dashboards if you're running your own node. For more granular control, simulate realistic workloads like NFT mints, asset transfers, or dApp-specific calls.

Make sure you isolate variables by disabling non-essential logging, syncing, and background processes during benchmarking. Use --num-workers and --num-transactions flags in the benchmark CLI to test various load scenarios. You should also compare throughput with shared objects versus owned object transactions, as shared object execution can be more complex. Capture logs and error rates to detect bottlenecks, especially around gas usage and consensus latency. Repeat the test under different network conditions to assess stability and consistency.

To benchmark Sui’s throughput on Testnet:

Tools: Sui Benchmarker: Official tool in the Sui GitHub repo (sui-benchmark).

Custom scripts: Use sui-sdk or CLI to send batched txs.

Third-party load testers: Tools like Chainhammer (if adapted to Sui).

Method: Use multiple accounts and send parallel transactions.

Track TPS (tx/sec) and latency.

Vary tx types (e.g. coin transfers vs. Move calls).

Run tests at different times to avoid RPC throttling.

Use local fullnodes or dedicated RPCs for accurate, uncontested results.

You should begin by setting up a Testnet environment using sui start --testnet or switch your CLI to Testnet to ensure you’re testing in the correct network context. Once ready, use a stress-testing methodology by generating and sending many independent transactions in parallel, especially those that involve owned object operations—this leverages Sui’s parallel execution model and avoids shared-object contention bottlenecks. You can employ the Sui CLI with sui client batch to submit a file of preconstructed transactions at high concurrency, or write a custom script using the JavaScript SDK to fire many signAndExecuteTransactionBlock calls concurrently. Always monitor throughput metrics like transactions per second (TPS), latency, and conflict rates using CLI feedback or logs—you can script repeated dry-runs to establish baseline costs before actual deployment. To get realistic performance, ensure your workload avoids shared-object hotspots, and measure under high-load scenarios where parallelism shines. After each test, analyze metrics, check for ConflictTransaction errors, and reflect on bottlenecks—then adjust your object and call patterns and test again. Building this in iterations gives you a step-by-step understanding of throughput ceilings under realistic conditions. Read more here: https://docs.sui.io/build/parallel-execution