Apex Bundles

What a Bundle Is

A bundle is a group of 1 to 4 transactions that execute in order and all or nothing. Either every transaction in the bundle lands in the same block, in the order you gave, or none of them do. Use a bundle when a later transaction only makes sense if an earlier one succeeded, for example a setup transaction followed by a swap.

Bundles only land on Jito-enabled leaders. A group of transactions cannot be kept atomic on the stake-weighted or direct TPU paths, so bundles go to the block engine path only. When the current leader does not run Jito, the bundle waits for the next one that does. For a single transaction, a regular send uses all three paths and lands sooner.

Rules

Rule	Detail
Size	1 to 4 transactions
Order	Executed in the order given
Atomicity	All or nothing
Tip	Exactly one transaction in the bundle carries the Apex tip, at or above your tier’s floor
Member size	Each transaction is limited to 1232 bytes. Transaction v1 sizes do not apply inside a bundle
Rate	2 bundles per second per API key, with a short burst of 4, on top of your transaction limit. Over it you get HTTP `429` or `-32029`
Status	`getInflightBundleStatuses` needs the API key that sent the bundle and takes up to 100 ids. A bundle sent with another key reads as `Invalid`
Retries	Apex resubmits the bundle, under the same bundle id, until it lands, the first transaction’s blockhash expires, or the resubmission budget runs out

The tip follows the same tip rule as a single send: one top-level SystemProgram transfer to a published tip account, funded by a signer, with the tip account in the static keys. That tip minus the 5,000 lamport base fee becomes the Jito bid for the whole bundle. Because the bundle is atomic, the tip is only paid if the entire bundle lands.

JSON-RPC sendBundle

Param	Type	Description
`params[0]`	string[]	1 to 4 signed transactions in execution order, all in the encoding named by `params[1]`
`params[1].encoding`	string	`"base64"` or `"base58"`

The result is a bundle id. Keep it to query the bundle’s status. sendBundle also accepts {"encoding": "base58"} for base58 encoded transactions. The examples below use base64.

# Two signed transactions from the helper in Sending transactions.
# Exactly one of them may carry the tip, so build the first one without it.
TX1=$(node -e 'import("./apex-tx.mjs").then(async (m) => console.log(Buffer.from((await m.buildTx({ tip: false, label: "apex bundle 1" })).serialize()).toString("base64")))')
TX2=$(node -e 'import("./apex-tx.mjs").then(async (m) => console.log(Buffer.from((await m.buildTx({ tip: true, label: "apex bundle 2" })).serialize()).toString("base64")))')

BUNDLE_ID=$(curl -s "$APEX_RPC" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $APEX_API_KEY" \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"sendBundle\",\"params\":[[\"$TX1\",\"$TX2\"],{\"encoding\":\"base64\"}]}" \
  | jq -r '.result // .error')
echo "bundle id: $BUNDLE_ID"

curl -s "$APEX_RPC" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $APEX_API_KEY" \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"getInflightBundleStatuses\",\"params\":[[\"$BUNDLE_ID\"]]}"

import { apexRpc, buildTx } from "./apex-tx.mjs";

// Exactly one transaction carries the tip.
const txs = [
  await buildTx({ tip: false, label: "apex bundle 1" }),
  await buildTx({ tip: true, label: "apex bundle 2" }),
];

const bundleId = await apexRpc("sendBundle", [
  txs.map((tx) => Buffer.from(tx.serialize()).toString("base64")),
  { encoding: "base64" },
]);
console.log("bundle id:", bundleId);

// Poll until the bundle settles.
for (;;) {
  const { value } = await apexRpc("getInflightBundleStatuses", [[bundleId]]);
  const { status, landed_slot } = value[0];
  if (status === "Landed") { console.log("landed in slot", landed_slot); break; }
  if (status === "Failed" || status === "Invalid") { console.log("bundle", status); break; }
  await new Promise((resolve) => setTimeout(resolve, 1000));
}

import base64
import time

from apex_tx import apex_rpc, build_tx

# Exactly one transaction carries the tip.
txs = [
    build_tx(tip=False, label="apex bundle 1"),
    build_tx(tip=True, label="apex bundle 2"),
]

bundle_id = apex_rpc("sendBundle", [
    [base64.b64encode(bytes(tx)).decode() for tx in txs],
    {"encoding": "base64"},
])
print("bundle id:", bundle_id)

# Poll until the bundle settles.
while True:
    entry = apex_rpc("getInflightBundleStatuses", [[bundle_id]])["value"][0]
    if entry["status"] == "Landed":
        print("landed in slot", entry["landed_slot"])
        break
    if entry["status"] in ("Failed", "Invalid"):
        print("bundle", entry["status"])
        break
    time.sleep(1)

The JavaScript and Python samples import the helper from Sending transactions. Response:

{ "jsonrpc": "2.0", "id": 1, "result": "<bundle id>" }

POST /send-bundle

The binary route takes the same framing as /send-batch: for each transaction, a big-endian u16 length followed by the raw transaction bytes, 1 to 4 frames in execution order.

import { APEX_RPC, API_KEY, buildTx } from "./apex-tx.mjs";

const txs = [
  await buildTx({ tip: false, label: "apex bundle 1" }),
  await buildTx({ tip: true, label: "apex bundle 2" }),
];

// Each frame: u16 big-endian length, then the transaction bytes.
const frames = txs.map((tx) => {
  const wire = Buffer.from(tx.serialize());
  const length = Buffer.alloc(2);
  length.writeUInt16BE(wire.length);
  return Buffer.concat([length, wire]);
});

const res = await fetch(`${APEX_RPC}/send-bundle`, {
  method: "POST",
  headers: { "Content-Type": "application/octet-stream", "x-api-key": API_KEY },
  body: Buffer.concat(frames),
});
const body = await res.json();
if (!body.bundle_id) throw new Error(`rejected ${res.status} ${body.error}: ${body.message}`);
console.log("bundle id:", body.bundle_id);
console.log("signatures:", body.signatures);

import struct

from apex_tx import APEX_RPC, build_tx, session

txs = [
    bytes(build_tx(tip=False, label="apex bundle 1")),
    bytes(build_tx(tip=True, label="apex bundle 2")),
]
# Each frame: u16 big-endian length, then the transaction bytes.
payload = b"".join(struct.pack(">H", len(wire)) + wire for wire in txs)

r = session.post(f"{APEX_RPC}/send-bundle", headers={"Content-Type": "application/octet-stream"},
                 data=payload, timeout=5)
body = r.json()
if "bundle_id" not in body:
    raise RuntimeError(f"rejected {r.status_code} {body['error']}: {body['message']}")
print("bundle id:", body["bundle_id"])
print("signatures:", body["signatures"])

Response:

{
  "bundle_id": "<bundle id>",
  "signatures": ["<signature of transaction 1>", "<signature of transaction 2>"]
}

Errors use the same format and status codes as the other plain HTTP routes. A bundle refused as a whole comes back with the bundle label.

Track a Bundle

Call getInflightBundleStatuses with an array of bundle ids:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getInflightBundleStatuses",
  "params": [["<bundle id>"]]
}

The result carries one entry per bundle id, in the order you asked:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "context": { "slot": 367112345 },
    "value": [
      { "bundle_id": "<bundle id>", "status": "Landed", "landed_slot": 367112344 }
    ]
  }
}

landed_slot is the slot the bundle landed in, or null when it has not landed. status is one of four states:

Status	Meaning
`Pending`	Apex holds the bundle and is still submitting it
`Landed`	The bundle landed. `landed_slot` holds the slot
`Failed`	The bundle did not land before the first transaction’s blockhash expired, or the resubmission budget ran out
`Invalid`	The bundle id is unknown to this Apex endpoint, or is older than five minutes

The bundle id stays the same while Apex resubmits, so keep polling the id you got when you sent the bundle. Ask the same Apex endpoint you sent the bundle to. Bundle ids are not shared between endpoints. Since a bundle is atomic, you can also confirm it like any transaction: once any of its signatures shows up as confirmed in getSignatureStatuses on a Solana RPC, the whole bundle landed.

Bundle or Batch?

	Bundle	Batch
Transactions	1 to 4	Up to 16
Atomic	Yes	No, each is independent
Ordered	Yes	No
Tip	One for the whole bundle	One per transaction
Paths	Jito block engine only	All three
Member size limit	1232 bytes	1232 bytes, or 4096 for v1

Get Started

Agents

Products

Solutions

Fetching Data

RPC

Data Streaming

Apex

Trading APIs

What a Bundle Is

Rules

JSON-RPC sendBundle

POST /send-bundle

Track a Bundle

Bundle or Batch?

​What a Bundle Is

​Rules

​JSON-RPC sendBundle

​POST /send-bundle

​Track a Bundle

​Bundle or Batch?

What a Bundle Is

Rules

JSON-RPC sendBundle

POST /send-bundle

Track a Bundle

Bundle or Batch?