Send a Jito-style transaction bundle

Submits a bundle of pre-signed Solana transactions to be landed together with an all-or-none guarantee: either every transaction in the bundle is included, in the exact order you supply them, or none of them are. This is the right tool when a sequence of transactions only makes sense executed atomically — for example an arbitrage leg plus its settlement, or a setup transaction that must not land without its follow-up.

You may include between 1 and 5 base64-encoded, fully signed transactions. The bundle is forwarded to a block-engine relayer for inclusion. To bid for priority inclusion, add a tip_lamports amount; higher tips improve the odds (and speed) of the bundle landing during periods of contention.

A successful response returns immediately with a bundle_id you can use to correlate the submission, along with the signatures of the transactions in the bundle. Submission does not wait for on-chain confirmation — poll the transaction signatures (e.g. via getSignatureStatuses / getTransaction) to confirm landing.

Note: every transaction must already be signed and carry a recent, still valid blockhash before you submit. The endpoint does not sign on your behalf.

Send a JSON object as the request body.

Response fields

All errors share the standard JSON envelope (error, message, request_id). See the errors reference for the full envelope and per-code fields (e.g. current_tier / required_tier on 403, retry_after_sec on 429).

JavaScript (fetch)

const res = await fetch("https://api.triport.io/v1/sol/sender/bundle", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    txs: [signedTx1Base64, signedTx2Base64],
    tip_lamports: 100000,
  }),
});


if (!res.ok) {
  throw new Error(`bundle failed: ${res.status} ${await res.text()}`);
}


const { bundle_id, signatures } = await res.json();
console.log("submitted bundle", bundle_id, signatures);

TypeScript SDK (@triport/sdk)

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


const client = new Triport({ apiKey: process.env.TRIPORT_API_KEY! });


const { bundleId, signatures } = await client.sol.sender.bundle({
  txs: [signedTx1Base64, signedTx2Base64],
  tipLamports: 100_000,
});


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

Python (triport-sdk)

import os
from triport import Triport


client = Triport(api_key=os.environ["TRIPORT_API_KEY"])


result = client.sol.sender.bundle(
    txs=[signed_tx_1_base64, signed_tx_2_base64],
    tip_lamports=100_000,
)


print("submitted bundle", result.bundle_id, result.signatures)

• Atomicity: transactions land together in the order given, or not at all. Order your txs array exactly as they must execute.
• Bundle size: 1–5 transactions. A request with 0 or more than 5 entries is rejected with 400.
• Tips: tip_lamports is a competitive bid for inclusion, not a network fee on top of each transaction's own priority fees. Size it to current contention.
• Confirmation: a 200 means the bundle was accepted for forwarding, not that it has landed. Track the returned signatures to confirm on-chain inclusion.
• Single transactions: if you only need to send one independent transaction, use POST /v1/sol/sender/send, which is available on the free tier.