devbundler
Launch

pump.fun Bundler Feature Checklist: What a Good Tool Needs

A feature checklist for pump.fun bundlers: wallet management, launch mechanics, checks before sending, batch trading, exits, safety and cost. Use it to compare tools.

By DevBundler Team · · 4 min read

The short answer

A good pump.fun bundler covers the whole launch: generating and funding wallets, sending the create and every launch buy in one Jito bundle, checking balances and the curve before sending, trading and selling across wallets afterwards, and sweeping SOL back out. It should also show its fees and your combined supply share before you confirm.

Key takeaways

  • Launch features matter, but most problems show up afterwards, in batch selling and moving SOL back out.
  • The launch should be one Jito bundle on mainnet, with the dev buy first and every buyer quoted in send order.
  • Pre-send checks should catch short balances, a used coin address and buys that would sell out the curve before anything is sent.
  • Batch sells need in-order quoting, or later wallets fail slippage with error 6003.

Use this list to compare pump.fun bundlers feature by feature. It is grouped by the order you will need things: wallets first, then the launch, then everything after. Each item says why it matters, and where it applies we note what DevBundler does, so you have a reference point.

One thing up front: the launch is the part every tool advertises, but most painful problems show up after it. A tool that launches cleanly and then makes selling from ten wallets a chore is not a good tool.

Wallet management

You will use several wallets per launch, so creating, funding and emptying them has to be quick.

Wallet features

  • Generate many wallets at once, with labels and groups.
  • Import existing keys if you want to.
  • Live SOL and token balances per wallet.
  • Distribute SOL from one wallet to many, in equal or custom amounts.
  • Consolidate: sweep wallets back into one, with the option to close token accounts.
  • Export a key, behind a password check.

Closing token accounts matters more than it sounds. Each one holds about 0.002 SOL of rent, refundable on close. Across many wallets and launches, that adds up.

DevBundler covers all of these. It can generate hundreds of wallets at once, distribute SOL now or spread over time on an interval, and consolidate with an option to keep rent or close token accounts. How to create and fund launch wallets walks through it.

Launch mechanics

This is the core of a bundler. Check the details, not the headline.

Launch features and why they matter

FeatureWhy it mattersDevBundler
One Jito bundle on mainnetSame block, all or nothing, no outside buys in betweenYes: create, dev buy and up to 10 buyers in 5 transactions
Address lookup tableWithout one, a create with buys does not fit 1232 bytesReusable per account, about 0.005 SOL once
Buy by SOL or by % of supply% targets give you the split you actually wantBoth, same for all or custom per wallet
In-order quotesLater wallets pay more; quotes should match what landsEach wallet quoted after the ones before it
Image uploadThe coin needs an image hosted somewhere permanentUploaded to IPFS
Devnet modePractice with free test SOLYes, sent one after another (no Jito on devnet)

If a tool cannot say exactly how many transactions its launch uses and what is in each, assume the buys may land in different blocks.

Checks before sending

Mistakes are cheap before you send and expensive after. A good tool shows you everything that will happen and refuses to send a launch that will fail.

Pre-send features

  • A table of every wallet: balance, buy, estimated % of supply and SOL needed.
  • Wallets short on SOL flagged, and the launch blocked until fixed.
  • Buys that would sell out the whole bonding curve blocked.
  • Combined supply share across your wallets shown before launch.
  • Fee and tip shown in the final confirmation.
  • A quick check that pump.fun is reachable and the coin address is unused.

DevBundler does all of these. It does not run a separate simulation step; it runs one fast check right before sending, and if that fails, nothing is sent and the project page shows the reason with a "Launch again" button.

After launch: trading and exits

This is where tools separate.

  1. 1

    A project dashboard

    Market cap, bonding curve progress, combined holdings and % of supply, value if sold, profit and loss per wallet.

  2. 2

    A chart with your trades marked

    So you can see where you bought and sold against the market. DevBundler builds candles from 15 seconds to 1 hour from on-chain trade history and marks your buys and sells as B and S.

  3. 3

    Batch buy and sell

    Tick wallets or All, press a preset, done. Presets should be editable, and keyboard shortcuts help when things move fast.

  4. 4

    In-order quoting for batches

    Each wallet's quote should account for the trades before it, or sells fail with 6003.

  5. 5

    Automatic switch after migration

    When the curve completes, trading moves to PumpSwap. You should not have to change anything.

Point 4 is the one to test hardest. Why batch sells fail explains the slippage problem in detail.

On mainnet, it also helps to have a choice of how a batch is sent: each wallet as its own transaction right away (DevBundler's "Fast"), or packed into one Jito bundle in the same block ("Bundle", a Premium feature). Speed presets that set the priority fee (Normal, Fast and, on Premium, Turbo) let you pay more only when you need to.

Safety and custody

Safety features

  • A clearly explained custody model: who holds keys, how they are encrypted.
  • Keys never written to logs.
  • Password required again to export a key, and the key shown only briefly.
  • Sessions that lock after idle time.
  • Mainnet clearly marked and confirmed, so you do not spend real SOL by accident.

DevBundler is hosted and custodial: keys are stored encrypted with AES-256-GCM, export needs your password and shows the key for 10 seconds, sessions auto-lock, and mainnet is shown in red with a confirmation. Browser wallet vs hosted bundlers explains what that model means for you.

Cost

  • Fees shown before every confirmation, not discovered afterwards.
  • A clear statement of which actions carry a fee (launch, trades, both).

Features that are nice but not essential

Essential

  • One-bundle launch with in-order quotes
  • Pre-send checks that block bad launches
  • Batch selling that works
  • Consolidate with account closing
  • Clear custody and fees

Nice to have

  • Scheduled SOL distributions
  • CSV export of trades
  • Longer chart history
  • Keyboard shortcuts
  • Bundle mode for trades

Several of the nice-to-haves are part of DevBundler Premium. Start with the essentials and add the rest only if you find you need them.

Frequently asked questions

›What features should a pump.fun bundler have?

At minimum: wallet generation and funding, a launch sent as one Jito bundle, per-wallet quotes, checks before sending, batch buying and selling across wallets, and a way to sweep SOL back into one wallet. Clear fees and a clear custody model matter as much as features.

›Why do batch sells fail in some bundlers?

If every wallet's sell is quoted against the same starting price, each later sell gets less SOL than its slippage minimum and fails with error 6003. Quoting each wallet in order, after the sells before it, avoids this.

›Does a bundler need a lookup table?

To fit a pump.fun create plus several buys into a Jito bundle's five transactions, yes. An address lookup table lets each transaction reference many accounts with 1-byte indexes so it stays under the 1232-byte limit.

›What happens to my trades after the bonding curve completes?

The coin migrates to PumpSwap and trades there. A good bundler switches its buy and sell routing automatically; DevBundler does this without you changing anything.

Keep reading