Launching on pump.fun? What on-chain forensics see in your token

You are launching a real project on pump.fun. You have a plan, a community, maybe an actual product. Here is the part nobody puts in the launch threads: your buyers will not read your roadmap — their tools will read your chain history. Within seconds of the create transaction, screeners and bots pull your creator card, group your first buyers into bundles, walk your wallet's funding chain and compute a live risk score. A launch that trips the flags is dead on arrival, even if you are honest. This guide walks through exactly what the forensics see, signal by signal, using the Raiden API — the same data the other side of your order book is looking at.

The audit happens before your tweet loads

The modern pump.fun buyer does not evaluate tokens; they evaluate launches. The moment your mint exists, tooling fetches everything at once — on Raiden, a single GET /tokens/{mint}/pack call returns the whole dossier: the launch bundle analysis, the funding clusters among early buyers, the wash-trading estimate, any known rug-dumpers present, and a Raiden Trust score from 0 to 100 (higher = safer) with a verdict: clean at 65+, caution from 40 to 64, likely_rug below 40. The score blends five weighted signals — dev reputation (0.35), known dumpers in the token (0.25), bundled supply (0.15), dev exit (0.10) and wash volume (0.15) — and every signal reports its raw value, so there is nowhere for a bad launch to hide and, just as importantly, nowhere for a clean one to be mistaken for a rug. Full breakdown of the scoring in the rug-check guide.

Your dev wallet is your resume

Before anyone looks at your token, they look at you. Every creator wallet has a public card — GET /creators/{addr}/stats — with a dev score from 0 to 100 (−1 means not scored yet) computed from the wallet's entire launch history:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/creators/YOUR_WALLET/stats"

{
  "creator": "YOUR_WALLET",
  "dev_score": 34,
  "flags": [
    { "id": "dev_dump",     "name": "Dev dumped after launch",   "category": "dev-rug" },
    { "id": "fresh_wallet", "name": "Throwaway creator wallet",  "category": "sybil" }
  ],
  "token_count": 87,
  "graduated_count": 3,
  "survival_rate": 0.08,
  "dev_dump_count": 23,
  "full_exit_count": 9,
  "held_clean_count": 4,
  "rug_events": 11,
  "distinct_symbols": 52,
  "max_burst_10m": 6,
  "wallet_age_days": 6.4,
  "funder_kind": "exchange",
  "shared_funder_degree": 18,
  "sibling_creators": 7
}

Read that card the way a buyer's bot does. token_count vs graduated_count and survival_rate: how many launches lived. dev_dump_count and full_exit_count: how many times this wallet sold into its own community. rug_events: launches that ended in a coordinated dump. max_burst_10m and distinct_symbols: whether the wallet sprays tokens in bursts and recycles tickers — the behavior behind the spam_rate, serial_count, burst and ticker_recycle flags. The uncomfortable implication for founders: every cheap test launch you fired off last month is on this card, dragging the score of the launch you actually care about. Ten dead "practice" tokens read exactly like a serial spammer, because on-chain they are indistinguishable from one. The dev-wallet guide shows how buyers read this card in detail — assume they have.

A fresh wallet does not reset anything

The obvious workaround — rotate to a clean wallet — fails twice. First, the clean wallet has to be funded from somewhere, and GET /wallets/{addr}/funding-chain walks that trail hop by hop, from depth 0 (the direct funder) back to the root — a CEX hot wallet or a known entity. Creator cards carry the graph view of the same fact: shared_funder_degree and sibling_creators count how many other creator wallets came from your funder, and rotation_count_30d counts wallets you cycled SOL out to and back within 30 days. A two-day-old wallet whose funder has spawned a dozen creators is not anonymous — it is a pattern, and fresh_wallet ("Throwaway creator wallet") is one of the flags shown next to your token. Second, even where the chain is genuinely cold, a wallet with no history does not score as trustworthy; unknown reputation is treated as mid-pack, not clean. The only wallet that helps you is the one with good launches on it.

Bundling caps your score — mathematically

The strongest single signal is what happens in your token's first slots. GET /tokens/{mint}/launch groups the first swaps into bundles — same slot, consecutive block indexes — and totals bundled_pct_supply, with has_dev marking bundles your own wallet sat in. Buyers see this within seconds (the bundle-checker guide is the buyer-side view). What founders usually don't realize is that heavy bundling doesn't just lower the trust score — it caps it. Penalties start above ~10% of supply bought in bundles, and from 50% a hard ceiling kicks in that no other signal can lift:

So if you pre-buy 55% of supply with "team wallets", your token launches with a mathematical maximum of 35 — caution territory at best, forever, no matter how real the project is. And funding those team wallets from your own dev wallet makes it worse: GET /tokens/{mint}/funding-clusters groups early buyers by shared origin-funder and sets is_dev: true on the cluster funded by the creator. Every screener renders that as "the dev controls the float" — because, on-chain, that is what it is.

Your exit is public, live

The dev_exit signal is not a snapshot — it is computed live from your position: the fraction of what you bought that you have already sold. Selling up to 20% costs nothing; selling into the first pump does, and at 80%+ sold the signal zeroes out and caps the score at 45 while your token is still on everyone's screen. It also follows you: every token on your creator card carries dumped, dev_hold_pct and dev_realized_pnl, and each dump increments the dev_dump_count that feeds your next launch's dev score. Taking profit is not forbidden — it is measured, and the difference between trimming 15% and exiting 90% is the difference between a signal that stays green and a permanent entry on your resume.

Wash trading your own chart backfires

The other tempting shortcut — cycling volume through your own wallets to look alive — is specifically detected. GET /tokens/{mint}/wash-traders flags round-trippers (wallets with ≥5 buys and ≥5 sells in the last 24h) and estimates wash_pct, the share of volume that is artificial. Penalties start above ~5%, and at 40% the trust score caps at 45 with cap_reason: "wash_trading". The volume you faked to attract buyers is the exact reason their tools tell them to stay away.

What a clean launch looks like on-chain

Flip every signal above and you have the checklist. Launch from one wallet with history — ideally one whose card already shows held_clean_count and a graduation. Keep coordinated early buying under ~10% of supply, and never fund early buyers from the dev wallet. Hold visibly: a dev position that stays mostly intact keeps dev_exit green in real time. Let volume be organic — thin and honest beats thick and flagged. And check the mirror before and after:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/tokens/YOUR_MINT/trust"

{
  "score": 86,
  "verdict": "clean",
  "capped": false,
  "cap_reason": "",
  "signals": {
    "dev_score":       { "value": 61,  "comp": 61.0, "known": true },
    "dumpers_holding": { "value": 0,   "comp": 100.0, "known": true },
    "bundled_pct":     { "value": 6.2, "comp": 100.0, "known": true },
    "dev_exit":        { "value": 12.0, "comp": 100.0, "known": true },
    "wash_pct":        { "value": 3.1, "comp": 100.0, "known": true }
  },
  "weights": { "dev": 0.35, "offenders": 0.25, "bundle": 0.15, "exit": 0.10, "wash": 0.15 }
}

If capped is true, the cap_reason names the one thing killing you — fixable before launch (bundling, funding), or at least explainable to your community (a flagged early buyer you did not invite).

Reputation compounds — and buyers filter by it

Here is the payoff for doing it right. Dev scores are recomputed from the full record, so graduations, surviving tokens and clean holds raise the number every launch — your fifth clean launch starts warmer than your first. And the number is not decorative: the token screener prints dev_score and dev_flags on every row, GET /creators supports a min_score filter for bulk discovery, and WebSocket creation streams can be scoped to a curated dev list — meaning a real cohort of buyers subscribes only to launches from wallets that pass their bar. A good pump.fun dev reputation is literally distribution: your create transaction shows up in feeds that other devs' launches never reach.

None of this is moral advice — it is a description of the scoreboard. The forensics do not care why 60% of your supply moved in one bundle; they report that it did, and the market prices it. If you want to launch a pump.fun token successfully in 2026, design the launch so that the tools describing it have nothing to say. The full endpoint reference — trust, launch, funding clusters, creator cards — is in the API docs, and the buyer-side playbooks are one link away: how buyers rug-check your token, how they detect bundles and how they read your dev wallet.