simulateBundle

simulateBundle simulates the execution of an ordered bundle of Solana transactions exactly as they would run if landed back-to-back in a single block, and returns the per-transaction outcome — without submitting anything to the network. Use it to validate an MEV / atomic-arbitrage bundle (or any sequence of dependent transactions) before paying to send it with the bundle-submission methods.

Because the transactions are simulated in order against the same working state, later transactions in the bundle observe the account changes produced by earlier ones. This is the key difference from calling simulateTransaction on each transaction independently: a bundle that only succeeds atomically (for example, a swap that funds a later repay) can be validated as a whole.

This is a pro-tier-only method. It is rate-limited under the sol_sim_bundle category at 5 RPS (pro) / 15 RPS (business), with burst headroom of twice the sustained limit.

JSON-RPC params is a positional array with a single bundle object: [{ "encodedTransactions": [...] }].

The result is an open object (context / value); additional per-transaction fields may appear beyond those documented below.

Errors are returned in the standard JSON-RPC error envelope. See the shared errors reference for the full envelope shape and shared codes.

A tier-insufficient response looks like:

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32002,
    "message": "Method 'simulateBundle' requires pro tier or higher",
    "data": {
      "current_tier": "free",
      "required_tier": "pro",
      "method": "simulateBundle",
      "category": "sol_sim_bundle",
      "upgrade_url": "https://triport.io/upgrade/pro"
    }
  }
}

JavaScript (fetch)

const res = await fetch("https://triport.io/sol", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "simulateBundle",
    params: [{ encodedTransactions: [base64Tx1, base64Tx2] }],
  }),
});


const { result, error } = await res.json();
if (error) throw new Error(`${error.code}: ${error.message}`);


const ok = result.value.transactionResults.every((t) => t.err === null);
console.log(ok ? "bundle simulated clean" : "bundle would revert");

TypeScript SDK (@triport/sdk)

import { TriportClient } from "@triport/sdk";


// simulateBundle requires a pro-tier (or higher) API key.
const client = new TriportClient({ apiKey: process.env.TRIPORT_API_KEY });


const { value } = await client.solana.simulateBundle(
  { encodedTransactions: [base64Tx1, base64Tx2] }
);


const ok = value.transactionResults.every((t) => t.err === null);
console.log(`bundle ${ok ? "OK" : "would fail"}`);

Python (triport-sdk)

import os
from triport import TriportClient


# simulateBundle requires a pro-tier (or higher) API key.
client = TriportClient(api_key=os.environ["TRIPORT_API_KEY"])


result = client.solana.simulate_bundle(
    {"encodedTransactions": [base64_tx_1, base64_tx_2]},
)


ok = all(t["err"] is None for t in result["value"]["transactionResults"])
print("bundle simulated clean" if ok else "bundle would revert")

• Encoding: transactions must be base64-encoded strings inside encodedTransactions. The result value envelope is open — new per-transaction fields may be added over time.
• Pro tier only: sol_sim_bundle has no free or basic access — see rate limits and tiers.
• Ordering matters: transactions are simulated in array order against a shared state, so a later transaction sees earlier transactions' effects. This is what makes it suitable for validating atomic bundles.
• Dry-run only: simulateBundle never broadcasts. Once a bundle simulates cleanly, submit it with the Solana bundle-submission methods.
• Related methods: use simulateTransaction to dry-run a single transaction independently, and sendTransaction to broadcast one transaction at a time.