Pump.fun bundle checker: how to detect bundled launches on-chain

A token launches on pump.fun. Within one slot it has forty holders and a green candle. Distribution looks healthy — until you notice the forty wallets bought in the same block as the creation, in consecutive positions, funded from the same wallet two hops back. That is a bundled launch, and it is the single most reliable early predictor of a dump. This guide is a practical pump.fun bundle checker: how bundling works, how to detect it from raw chain data with the Raiden API, and how to read the numbers honestly.

What a bundled launch is

Bundling is supply capture disguised as distribution. The operator prepares a set of wallets, then submits the token creation and a series of buys from those wallets as one atomic package, so everything executes in the same slot as the creation — often literally adjacent in the block, before any outside buyer can react. Two goals:

• Capture supply at the floor. The bonding curve is cheapest at slot zero. Buying 30–60% of supply in the creation block costs a fraction of what accumulating it later would.
• Fake the distribution. One wallet holding 40% screams exit scam. Forty wallets holding 1% each looks like a community — until you check how they landed and who funded them.

Why it predicts dumps: the wallets act as one hand. When the operator exits, they exit together — the same coordination that packed the buys into one block packs the sells into one candle. A launch where a coordinated cluster holds 40%+ of supply is not asking whether it will dump, only when.

The bundle flag: /tokens/{mint}/launch

The launch endpoint replays the first swaps of a token and groups them into bundles by slot and adjacent block index — consecutive positions in the same block are one package. Every swap row that belongs to one carries "bundled": true:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/tokens/9xQm…pump/launch?limit=150"

{
  "mint": "9xQm…pump",
  "creator": "5Q5q…Funr",
  "bundled_pct_supply": 4.88888889,
  "dev_bundle_pct_supply": 4.88888889,
  "bundle_count": 1,
  "bundles": [
    {
      "slot": 339481577,
      "start_index": 412,
      "size": 2,
      "is_bundle": true,
      "has_dev": true,
      "wallets": ["5Q5q…Funr", "8psN…VRtf"],
      "sol_total": "488888889",
      "tokens_bought": "48888888900000",
      "pct_supply": 4.88888889,
      "swaps": [
        { "trader": "5Q5q…Funr", "is_buy": true, "sol_amount": "300000000",
          "slot": 339481577, "block_index": 412, "bundled": true,
          "tip": "1000000", "priority_fee": "30000000", "sig": "4Fr4…ULFK", … },
        { "trader": "8psN…VRtf", "is_buy": true, "sol_amount": "188888889",
          "slot": 339481577, "block_index": 413, "bundled": true, … }
      ]
    }
  ]
}

The headline numbers: bundled_pct_supply — total supply captured by all detected bundles; dev_bundle_pct_supply — the share taken by the bundle that contains the creator (has_dev: true); bundle_count — how many distinct packages landed. Inside each bundle, slot, start_index and size place it exactly in the block: here two buys at block positions 412–413 of the creation slot, dev included. Amounts are strings in lamports (1 SOL = 1e9), so a sol_total of "488888889" is ~0.49 SOL. Each swap also carries its tip and priority_fee — bundled buys paying identical tips to the same tip wallet are another coordination fingerprint.

Reading the numbers: what is normal, what is a red flag

Honest caveat: bundling percentage is a heuristic built on adjacency, and some teams bundle defensively to keep snipers from front-running their own community. That is why the next two checks exist — concentration and funding tell you whether the bundled supply is still one hand.

Concentration: /tokens/{mint}/holder-stats

A bundle that already distributed or sold is history; a bundle that still holds is a loaded gun. One call gives the live concentration:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/tokens/9xQm…pump/holder-stats"

{
  "holders": 1342,
  "held": "873421889999",
  "top10": "412889123456",
  "top25": "588123987654"
}

top10 / held here is ~47%: ten wallets control nearly half of the held supply. Read together with the launch data, the question becomes precise — are the top holders the bundle wallets? If bundled_pct_supply is 40% and the top-10 share is 45%, the bundle never left.

Insider detection: /tokens/{mint}/funding-clusters

This is where a solana bundle checker earns its keep, because sophisticated bundlers randomize everything visible — buy sizes, timing offsets, even skipping adjacency by spreading buys over a few slots. What they cannot randomize cheaply is where the SOL came from. The funding-clusters endpoint takes the token's early buyers and groups them by shared origin funder — the wallet that originally funded them, resolved through the transfer chain:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/tokens/9xQm…pump/funding-clusters"

{
  "early_buyers": 500,
  "clustered": 14,
  "clusters": [
    {
      "funder": "5Q5q…Funr",
      "funder_label": "Dev wallet",
      "count": 6,
      "is_dev": true,
      "wallets": ["8psN…VRtf", "Cb3f…g9rE", "Gm4w…9xZ2"]
    }
  ]
}

Fourteen of five hundred early buyers share an origin — and six of them trace straight back to the dev wallet (is_dev: true). Those six are the creator's supply wearing masks, whatever the holder list says. A large cluster with a non-dev funder is an insider ring or a professional bundling operation; either way, the wallets will sell as one.

How the Trust score treats bundled supply

You do not have to run this pipeline by hand on every token — /tokens/{mint}/trust compresses it into a live 0–100 score (higher = safer), and bundled supply is one of its five weighted signals (bundled_pct, alongside dev reputation, known rug-dumpers inside the token, dev exit and wash trading). Crucially, heavy bundling does not just lower the score — it caps it, in tiers: from 50% bundled the score cannot exceed 45 (caution at best), from 55% the ceiling drops to 35, and from 70% to 25 — deep inside the likely_rug band (verdicts: clean ≥65, caution 40–64, likely_rug <40). No amount of good behavior elsewhere can buy the verdict back:

{
  "mint": "9xQm…pump",
  "score": 45,
  "verdict": "caution",
  "capped": true,
  "cap_reason": "bundled",
  "signals": {
    "bundled_pct": { "value": 52.0, "comp": 0.0, "known": true },
    "dev_exit":    { "value": 100.0, "comp": 6.1, "known": true }, …
  },
  "weights": { "dev": 0.35, "offenders": 0.25, "bundle": 0.15, "exit": 0.10, "wash": 0.15 }
}

capped: true with cap_reason: "bundled" is the tell: the token scored higher on raw signals, and the bundle ceiling pulled it down. The tiering reflects what the data shows — heavy bundling correlates so strongly with a coordinated exit that treating a 62%-bundled token as merely "caution" would be lying to you. The full scoring model, including the other four signals, is covered in the pump.fun rug-check guide.

A complete bundle checker in Python

import requests

BASE = "https://terminal.raiden.wtf/api"
H = {"X-API-Key": "YOUR_KEY"}
MINT = "9xQm…pump"

launch = requests.get(f"{BASE}/tokens/{MINT}/launch", params={"limit": 150}, headers=H).json()
hs     = requests.get(f"{BASE}/tokens/{MINT}/holder-stats", headers=H).json()
fc     = requests.get(f"{BASE}/tokens/{MINT}/funding-clusters", headers=H).json()
trust  = requests.get(f"{BASE}/tokens/{MINT}/trust", headers=H).json()

bundled = launch["bundled_pct_supply"]
dev_b   = launch["dev_bundle_pct_supply"]
top10   = 100 * int(hs["top10"]) / int(hs["held"]) if int(hs["held"]) else 0
dev_cluster = sum(c["count"] for c in fc["clusters"] if c["is_dev"])

print(f"bundled {bundled:.1f}% (dev bundle {dev_b:.1f}%) in {launch['bundle_count']} bundle(s)")
print(f"top-10 hold {top10:.1f}% | {fc['clustered']}/{fc['early_buyers']} early buyers clustered"
      f" ({dev_cluster} funded by the dev)")
print(f"trust {trust['score']} → {trust['verdict']}"
      + (f"  [capped: {trust['cap_reason']}]" if trust["capped"] else ""))

# bundled 52.0% (dev bundle 12.3%) in 3 bundle(s)
# top-10 hold 47.3% | 14/500 early buyers clustered (6 funded by the dev)
# trust 45 → caution  [capped: bundled]

Market-wide: who is bundling right now

To scan for bundled supply on pump.fun at market scale instead of one token at a time, GET /ecosystem?window=24h includes a bundled_launches list — recent launches ranked by bundled share, with the wallet count and SOL deployed — plus bundlers, the wallets running bundle operations across the most tokens:

"bundled_launches": [
  { "mint": "9xQm…pump", "symbol": "WAGMI", "created_at": "2026-06-27T08:14:02Z",
    "pct_supply": 42.7, "wallets": 14, "lamports": "65500000000", "status": "bonding" }
],
"bundlers": [
  { "wallet": "Gm4w…9xZ2", "tokens": 37, "lamports": "182000000000" }
]

A wallet that has bundled 37 launches is not a trader — it is a factory, and every new token it touches inherits the history.

Checklist

• /tokens/{mint}/launch — bundled %, dev bundle %, per-swap bundled flag, exact block positions.
• /tokens/{mint}/holder-stats — is the bundled supply still concentrated in the top holders?
• /tokens/{mint}/funding-clusters — do the "independent" early buyers share an origin funder? Is it the dev?
• /tokens/{mint}/trust — the compressed verdict; capped + cap_reason: "bundled" means the bundle alone disqualifies the token.

Bundle detection is one third of a full pre-buy screen — the other two are the dev's track record and who else is inside the token, both covered in the complete pump.fun rug check. And since bundles and snipers share the creation block, the wallet landing comparison shows how to tell a fast independent sniper from a coordinated package. Full endpoint reference: API docs.