sendBundle

sendBundle submits an ordered bundle of fully-signed Solana transactions to be executed back-to-back, atomically, within a single block. Either every transaction in the bundle lands in the given order, or none of them do — there is no partial execution. This is the submission counterpart to simulateBundle, which dry-runs the same bundle without broadcasting it.

Because the bundle lands atomically and in order, later transactions can safely depend on the state changes produced by earlier ones (for example, a swap that funds a later repay). Use it for MEV / atomic-arbitrage strategies and any sequence of dependent transactions that must not be interleaved with other traffic.

This is a pro-tier-only method, rate-limited separately under the sol_send_bundle category at 10 RPS (pro) / 30 RPS (business), with burst headroom of twice the sustained limit. Always simulateBundle first: a bundle that would revert is rejected at submission, and you still consume your send budget.

JSON-RPC params is a positional array whose first element is the transaction array itself: [[tx1, tx2, ...], config?].

The result is an open object; additional fields may appear.

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 'sendBundle' requires pro tier or higher",
    "data": {
      "current_tier": "free",
      "required_tier": "pro",
      "method": "sendBundle",
      "category": "sol_send_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: "sendBundle",
    params: [
      [base64Tx1, base64Tx2],
      { encoding: "base64" },
    ],
  }),
});


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


console.log("bundle accepted:", result.bundleId);

TypeScript SDK (@triport/sdk)

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


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


const { bundleId, signatures } = await client.solana.sendBundle(
  [base64Tx1, base64Tx2],
  { encoding: "base64" }
);


console.log("submitted bundle:", bundleId, signatures);

Python (triport-sdk)

import os
from triport import TriportClient


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


result = client.solana.send_bundle(
    [base64_tx_1, base64_tx_2],
    encoding="base64",
)


print("submitted bundle:", result["bundleId"])

• Encoding: transactions are base64-encoded strings passed directly as the params[0] array. The result envelope is open — new fields may be added.
• Pro tier only: sol_send_bundle has no free or basic access — see rate limits and tiers.
• Atomic and ordered: the whole bundle lands together in array order or not at all — there is no partial inclusion.
• Simulate first: dry-run with simulateBundle before submitting; it shares the bundle model and catches reverts without spending your send budget.
• Acceptance ≠ landing: a successful response means the bundle was accepted, not confirmed. Poll getSignatureStatuses or getTransaction to verify it landed.
• Single transactions: to broadcast one transaction at a time, use sendTransaction instead.