Skip to main content

Lightning Bundle API

Lightning Bundle is PumpDev's server-signed Jito bundle API — execute up to 5 Pump.fun transactions atomically in one HTTP call. Buy, sell, and create tokens across multiple wallets with MEV protection, guaranteed execution order, and all-or-nothing reliability. No client-side signing, no manual bundle submission.

API Endpoint: POST https://pumpdev.io/api/bundle-lightning

Prerequisites​

You need a Lightning wallet with an API key. Create one via /api/wallet/create — it takes one call. Fund the wallet with SOL before trading (include enough for the Jito tip).

Why Lightning Bundle?​

FeatureLightning Bundle
SigningServer signs
SendingJito bundle endpoints
MEV ProtectionYes — Jito validators
Atomic ExecutionYes — all-or-nothing
Multi-WalletYes — up to 5 transactions
Mixed TypesYes — buy + sell + create in one
Jito TipDefault 0.01 SOL — 0.03 SOL when the bundle contains a create

When to Use Lightning Bundle​

  • MEV protection — Jito validators process your bundle privately, preventing front-running bots from seeing and acting on your trade before it lands
  • Atomic create + buy — token creation and dev buy land in the same block, so no one can snipe between create and buy
  • Multi-wallet bundles — coordinate up to 5 wallets buying a token simultaneously in one call
  • Higher landing rate — Jito validators prioritize tipped transactions over standard RPC submissions

Lightning Bundle vs Lightning Trade​

Lightning TradeLightning Bundle
Transactions1 per callUp to 5 per call
Atomic ExecutionN/A (single tx)Yes — all-or-nothing
Multi-WalletNoYes
Create + BuyNo (use Lightning Create)Yes — in one bundle
Jito TipNoYes (default 0.01 SOL, 0.03 with create)
Use CaseFast single tradesMEV-sensitive trades, token launches, multi-wallet coordination
When to Use Each
  • Lightning Trade: Fastest single buy/sell. One HTTP call, no Jito overhead.
  • Lightning Bundle: Atomic multi-transaction bundles via Jito. Best for token launches, sniper protection, and coordinated multi-wallet trades.

Rules​

Before building your request, note these constraints:

  • Max 5 accounts per bundle — the ceiling Jito allows. The tip is an instruction inside one of these transactions, so it costs no slot of its own
  • Bundles with a create entry tip more by default — 0.03 SOL instead of 0.01. A launch bundle bids against every other pump.fun launch in the same slot, and a losing bundle is dropped with no error: Jito still returns a bundle id. Measured on 2026-08-24: 0.02 SOL never landed, 0.03 SOL landed on the first slot every time. Raise it further when launches are contested.
  • Only one create entry allowed per bundle — it is auto-sorted to the first position
  • Same wallet can appear multiple times — e.g. create + buy from the same key, or two buys with different amounts
  • No sell alongside create — you can't sell a token that doesn't exist yet. Sell in a separate bundle after the token lands on-chain
  • One transaction carries the tip — the create entry when the bundle has one, otherwise the last entry. It is an instruction inside that transaction, not a transaction of its own
  • If a create entry is present, mint at the top level is not required (auto-generated)

Request Format​

Endpoint​

POST https://pumpdev.io/api/bundle-lightning

Body​

{
  "accounts": [
    { "apiKey": "key1", "type": "buy", "amount": 0.1, "denominatedInSol": "true" },
    { "apiKey": "key2", "type": "sell", "amount": "100%" }
  ],
  "mint": "TokenMintAddress",
  "jitoTip": 0.01,
  "slippage": 90,
  "priorityFee": 0.0005
}

Top-Level Parameters​

ParameterTypeRequiredDescription
accountsarrayYesArray of 1-5 transaction entries
mintstringYes*Token mint address (*not required if a create entry is present)
quoteMintstringNoQuote mint for bundles that include a create entry. Omit for native SOL/WSOL pairs
slippagenumberNoSlippage percentage (default: 90)
priorityFeenumberNoPriority fee in SOL (default: 0.0005)
jitoTipnumberNoJito tip in SOL (default: 0.01, or 0.03 when the bundle contains a create). Only one transaction carries the tip. Increase it when you want to bid more aggressively for bundle inclusion
mayhemModebooleanNoEnable Pump.fun Mayhem Mode on created tokens in this bundle

Account Entry — type: "buy"​

ParameterTypeRequiredDescription
apiKeystringYesWallet API key
typestringYes"buy"
amountnumberYesAmount to buy
denominatedInSolstringNoLegacy field name. Set "true" when a buy amount is in the pair's quote asset: SOL for SOL pairs, USDC for USDC pairs

Account Entry — type: "sell"​

ParameterTypeRequiredDescription
apiKeystringYesWallet API key
typestringYes"sell"
amountnumber/stringYesAmount to sell. Supports "100%", "50%", or exact amount
denominatedInSolstringNoKeep "false" for sell percentages or exact token amounts
closeTokenAccountbooleanNoClose token ATA after selling to reclaim ~0.002 SOL rent. Auto-enabled on "100%" sells. Set false to disable

Account Entry — type: "create"​

ParameterTypeRequiredDescription
apiKeystringYesCreator wallet API key
typestringYes"create"
namestringYesToken name (max 32 chars)
symbolstringYesToken symbol (max 10 chars)
imagestringYes*Image URL for token logo (*not required if uri provided)
uristringNoPre-uploaded metadata URI — skips server-side storage
descriptionstringNoToken description
twitterstringNoTwitter/X URL
telegramstringNoTelegram URL
websitestringNoWebsite URL
quoteMintstringNoOverride the top-level quote mint for this create entry
mintKeypairstringNoBase58-encoded mint secret key (vanity address)
cashbackEnabledbooleanNoEnable cashback rewards for traders

Quote mint note: When a bundle contains a create entry, set quoteMint if you want the new coin quoted in USDC or another SPL token. Buy entries that follow the create should keep using amount with denominatedInSol: "true"; for non-SOL quote pairs that amount is interpreted in quote-token units.

Response​

{
  "results": [
    { "type": "buy", "signature": "5x7...", "publicKey": "...", "error": null },
    { "type": "sell", "signature": "3k9...", "publicKey": "...", "error": null }
  ],
  "mint": "TokenMintAddress"
}

For create entries, the result also includes mint and metadataUri:

{
  "type": "create",
  "signature": "4j2...",
  "publicKey": "...",
  "mint": "NewTokenMintAddress",
  "metadataUri": "https://pumpdev.io/metadata/uuid.json",
  "error": null
}

Examples​

Buy — Single Wallet​

const response = await fetch(
  'https://pumpdev.io/api/bundle-lightning',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        { apiKey: 'YOUR_KEY', type: 'buy', amount: 0.1, denominatedInSol: 'true' }
      ],
      mint: 'TokenMintAddress',
      jitoTip: 0.01
    })
  }
);
const { results } = await response.json();
console.log('Buy executed via Jito:', results[0].signature);
Override jitoTip When Bundle Landing Matters

bundle-lightning includes a default jitoTip because bundle submission is Jito-specific. Raise it during congestion when inclusion priority matters, or override it explicitly if you need different economics.

Multi-Wallet Sell​

Dump all 4 wallets at once — supports percentage-based amounts ("100%", "50%"):

const response = await fetch(
  'https://pumpdev.io/api/bundle-lightning',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        { apiKey: WALLET1_KEY, type: 'sell', amount: '100%' },
        { apiKey: WALLET2_KEY, type: 'sell', amount: '100%' },
        { apiKey: WALLET3_KEY, type: 'sell', amount: '50%' },
        { apiKey: WALLET4_KEY, type: 'sell', amount: '100%' },
      ],
      mint: 'TokenMintAddress',
      slippage: 99,
      jitoTip: 0.01
    })
  }
);
const { results } = await response.json();
console.log(`${results.filter(r => r.signature).length}/${results.length} sold`);

Multi-Wallet Buy​

Bundle up to 5 wallets buying the same token atomically — all land in the same block or none do:

const response = await fetch(
  'https://pumpdev.io/api/bundle-lightning',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        { apiKey: WALLET1_KEY, type: 'buy', amount: 0.5, denominatedInSol: 'true' },
        { apiKey: WALLET2_KEY, type: 'buy', amount: 1.0, denominatedInSol: 'true' },
        { apiKey: WALLET3_KEY, type: 'buy', amount: 0.3, denominatedInSol: 'true' },
        { apiKey: WALLET4_KEY, type: 'buy', amount: 0.2, denominatedInSol: 'true' },
      ],
      mint: 'TokenMintAddress',
      jitoTip: 0.01
    })
  }
);
const { results } = await response.json();
console.log(`${results.filter(r => r.signature).length}/${results.length} succeeded`);

Create Token + Dev Buy​

Launch a token and buy it in the same block. The create entry is auto-sorted to position 1, so your buy executes immediately after — no one can snipe between them:

const response = await fetch(
  'https://pumpdev.io/api/bundle-lightning',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        {
          apiKey: 'YOUR_KEY', type: 'create',
          name: 'pumpdev.io', symbol: 'pumpdev.io',
          image: 'https://pumpdev.io/img/logo.jpg',
          quoteMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
          twitter: 'https://x.com/MyToken',
          website: 'http://pumpdev.io/'
        },
        { apiKey: 'YOUR_KEY', type: 'buy', amount: 25, denominatedInSol: 'true' }
      ],
      jitoTip: 0.01
    })
  }
);
const { results, mint } = await response.json();
console.log(`Token launched: https://pump.fun/${mint}`);
console.log('Create sig:', results[0].signature);
console.log('Buy sig:', results[1].signature);

Create Token + Creator Buy + 3 Buyers​

The full launch: the creator mints the token, the creator buys first, and three other wallets buy right behind — five transactions filling every slot of a Jito bundle. All five land in the same block or none of them do, so nobody can slip a buy in between the create and your own.

const response = await fetch(
  'https://pumpdev.io/api/bundle-lightning',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        // 1. Create the token (auto-sorted to the front, carries the tip)
        {
          apiKey: CREATOR_KEY, type: 'create',
          name: 'My Token', symbol: 'MTK',
          image: 'https://example.com/logo.png'
        },
        // 2. Creator buy — a separate entry, the create itself takes no amount
        { apiKey: CREATOR_KEY, type: 'buy', amount: 0.5, denominatedInSol: 'true' },
        // 3-5. Three more wallets, each its own transaction
        { apiKey: BUYER1_KEY, type: 'buy', amount: 1.0, denominatedInSol: 'true' },
        { apiKey: BUYER2_KEY, type: 'buy', amount: 0.5, denominatedInSol: 'true' },
        { apiKey: BUYER3_KEY, type: 'buy', amount: 0.25, denominatedInSol: 'true' },
      ],
      jitoTip: 0.03
    })
  }
);

const { results, mint } = await response.json();
console.log(`Token: https://pump.fun/${mint}`);
for (const r of results) {
  console.log(`${r.type} ${r.publicKey}: ${r.signature ?? r.error}`);
}

Things that trip people up here:

  • The creator buy is its own entry. A create entry takes no amount — it only mints the token. To have the creator buy, add a second entry of type buy using the same apiKey. That is why this launch costs 5 slots, not 4.
  • Five is the ceiling. A Jito bundle holds at most 5 transactions, so a creator buy leaves room for exactly 3 other buyers. Need more wallets? Send the extras as a second bundle right after — they will land a block later.
  • Tip like a launch, not like a trade. Launch bundles compete with every other pump.fun launch in the slot. At 0.01 SOL the bundle is simply outbid and dropped, and Jito reports no error — it returns a bundle id either way. The default for a bundle containing a create is 0.03 SOL for that reason.
  • Order is preserved. Buys execute in the order you list them, so the entry right after the create gets the best price on the curve.
  • results is per transaction. An entry that fails to build comes back with error set instead of signature, and the rest of the bundle still goes.

Automated Sniper Bot with Jito​

Combine WebSocket streaming + Lightning Bundle for a sniper bot. The bot watches for new token launches and buys instantly via Jito:

import WebSocket from 'ws';

const API_URL = 'https://pumpdev.io';
const WS_URL = 'wss://pumpdev.io/ws';

// 4 wallets sniping together in one atomic bundle
const WALLET_KEYS = [
  'pk_wallet1_xxxxxxxx',
  'pk_wallet2_xxxxxxxx',
  'pk_wallet3_xxxxxxxx',
  'pk_wallet4_xxxxxxxx',
];

const BUY_AMOUNT_SOL = 0.01;
const JITO_TIP = 0.01;
const MAX_MARKET_CAP_SOL = 50;

let isBuying = false;

const ws = new WebSocket(WS_URL);

ws.on('open', () => {
  ws.send(JSON.stringify({ method: 'subscribeNewToken' }));
  console.log('Watching for new tokens (4-wallet Jito sniper)...');
});

ws.on('message', async (data) => {
  const event = JSON.parse(data.toString());

  const marketCap = event.marketCapQuote ?? event.marketCapSol ?? 0;

  if (
    event.txType === 'create' &&
    event.quoteMint === 'So11111111111111111111111111111111111111112' &&
    marketCap <= MAX_MARKET_CAP_SOL &&
    !isBuying
  ) {
    console.log(`New token: ${event.name} (${event.symbol})`);
    await buyToken(event.mint);
  }
});

async function buyToken(mint) {
  isBuying = true;
  try {
    const response = await fetch(
      `${API_URL}/api/bundle-lightning`,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          accounts: WALLET_KEYS.map(apiKey => ({
            apiKey, type: 'buy', amount: BUY_AMOUNT_SOL, denominatedInSol: 'true'
          })),
          mint: mint,
          jitoTip: JITO_TIP
        })
      }
    );

    const { results } = await response.json();
    const succeeded = results.filter(r => r.signature).length;
    console.log(`${succeeded}/${results.length} buys landed`);
    results.forEach((r, i) => {
      console.log(`  Wallet ${i + 1}: ${r.signature || r.error}`);
    });
  } catch (err) {
    console.error('Error:', err.message);
  } finally {
    isBuying = false;
  }
}
tip

Lightning Bundle sends your transaction through Jito validators, which prevents front-running bots from seeing and acting on your trade before it lands. This is especially important for sniper bots buying new tokens at launch.

Token Launch + Sell Strategy​

Launch a token with multiple buyer wallets, then sell from all wallets in a separate bundle. You cannot combine create + sell in the same bundle because the token must exist on-chain before it can be sold:

const API_URL = 'https://pumpdev.io';
const CREATOR_KEY = 'pk_creator_xxxxxxxx';
const BUYER1_KEY = 'pk_buyer1_xxxxxxxx';
const BUYER2_KEY = 'pk_buyer2_xxxxxxxx';
const BUYER3_KEY = 'pk_buyer3_xxxxxxxx';

// 1. Create token + buy from 4 wallets (atomic via Jito)
const createRes = await fetch(
  `${API_URL}/api/bundle-lightning`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        {
          apiKey: CREATOR_KEY, type: 'create',
          name: 'My Token', symbol: 'MTK',
          image: 'https://example.com/logo.png',
          quoteMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
        },
        { apiKey: CREATOR_KEY, type: 'buy', amount: 25, denominatedInSol: 'true' },
        { apiKey: BUYER1_KEY, type: 'buy', amount: 15, denominatedInSol: 'true' },
        { apiKey: BUYER2_KEY, type: 'buy', amount: 15, denominatedInSol: 'true' },
      ],
      jitoTip: 0.02
    })
  }
);
const { mint, results } = await createRes.json();
console.log(`Token launched: https://pump.fun/${mint}`);
console.log(`${results.filter(r => r.signature).length}/${results.length} succeeded`);

// 2. Later: sell from all wallets via a separate Jito bundle
const sellRes = await fetch(
  `${API_URL}/api/bundle-lightning`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        { apiKey: CREATOR_KEY, type: 'sell', amount: '100%' },
        { apiKey: BUYER1_KEY, type: 'sell', amount: '100%' },
        { apiKey: BUYER2_KEY, type: 'sell', amount: '100%' },
        { apiKey: BUYER3_KEY, type: 'sell', amount: '100%' },
      ],
      mint: mint,
      slippage: 99,
      jitoTip: 0.01
    })
  }
);
const sellResult = await sellRes.json();
console.log(`${sellResult.results.filter(r => r.signature).length}/${sellResult.results.length} sold`);

Jito Tip Recommendations​

The Jito tip incentivizes validators to include your bundle. Higher tips = faster landing.

ScenarioRecommended TipNotes
Standard buy/sell0.01 SOLDefault — good for most trades
Token launch (create + buy)0.02 SOLHigher priority for launches
Competitive sniper0.05+ SOLWhen speed is critical
Low urgency0.005 SOLMinimum viable tip
Tip Cost

The Jito tip is a separate cost from the PumpDev trading commission. The tip goes directly to Jito validators. Only the last transaction in the bundle includes the tip. See Pricing for commission details.

Need client-side signing?

Use the Local-Sign Bundle API to build unsigned transactions, sign locally, and submit to Jito yourself.

Error Handling​

All errors return JSON with an error field. Common errors:

HTTP StatusErrorRoot CauseSolution
400Missing or invalid accounts arrayaccounts not provided or emptyProvide 1-5 account entries
400Maximum 5 accounts per bundleToo many entriesReduce to 5 or fewer
400type must be "buy", "sell", or "create"Invalid typeUse buy, sell, or create
400mint is required when no create entry is presentNo mint and no createProvide mint or add create entry
400Only one create entry allowed per bundleMultiple create entriesUse single create entry
400sell entries cannot be combined with createSell + create in same bundleSell in a separate bundle after the token exists
403invalid or deactivated API keyBad apiKey in accountsVerify wallet API key via Lightning Setup

Frequently Asked Questions​

What is the difference between Lightning Bundle and Lightning Trade?​

Lightning Trade sends a single transaction via standard RPC — fastest for simple buy/sell. Lightning Bundle wraps up to 5 transactions in a Jito bundle for atomic execution. Use Lightning Trade for speed on single trades; use Lightning Bundle when you need atomicity, multi-wallet coordination, or front-running protection.

What happens if one transaction in my bundle fails?​

The entire bundle fails. Jito bundles are atomic — all transactions succeed or none execute. No partial state changes occur on-chain.

Can I check the status of my bundle after submission?​

Lightning Bundle handles submission for you. If the API returns signatures in the results array, the bundle was accepted by Jito. You can verify on-chain status using the returned transaction signatures on any Solana explorer.

Can I use the same wallet for multiple entries?​

Yes. The same apiKey can appear in multiple account entries — for example, create + buy from the same wallet, or two buys with different amounts targeting different strategies.

Is there a retry mechanism if the bundle doesn't land?​

Lightning Bundle submits to Jito once. If the bundle is not included in a block (e.g., due to low tip during congestion), you need to submit a new request. Consider increasing the jitoTip during high-congestion periods.

Next Steps​

Last updated on