How to check if a pump.fun token will rug: the on-chain signals

Most rugs on pump.fun are not improvised. The dev wallet has done it before, the "community" filling the first slots is a paid bundle, the volume is round-tripped by a handful of wallets, and the accounts that will dump into your buy have dumped the exact same way on dozens of tokens already. All of it is visible on-chain before you buy — if you know where to look. This is a practical pump.fun rug checker: five signals, five endpoints of the Raiden API, one score that summarizes them, and a script you can run before every entry.

What a rug actually looks like on-chain

The honest answer to how to know if a pump.fun token will rug is that you can't — with certainty. What you can know is whether the setup matches the pattern, because a rug is one precise on-chain event: the dev (or the wallet operating the token) sells its position in a single slot, the price collapses, and a set of accomplice wallets exits with it — bundled in the same slot as the dev's sell, or sniping the dump within the next ~2 slots (~800ms). That event leaves permanent evidence: the dump slot is recorded, every wallet that sold inside it is flagged as a co-dumper, and doing that across many tokens turns a wallet into a repeat offender. Buyers in those slots lost money; they are victims and are never counted. The five signals below all key off this ground truth.

Signal 1 — the trust score: /tokens/{mint}/trust

If you make one call, make this one. Raiden Trust is a live 0–100 risk score (higher = safer) with a three-way verdict: clean (score ≥ 65), caution (40–64), likely_rug (below 40). It blends five weighted signals, and each one comes back with its raw value and its contribution (comp) to the final score — so you see not just the number but why:

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

{
  "mint": "9xQm…pump",
  "score": 42,
  "verdict": "caution",
  "capped": true,
  "cap_reason": "bundled",
  "rugged": false,
  "signals": {
    "dev_score":       { "value": 0,     "comp": 8.4,  "known": true },
    "dumpers_holding": { "value": 3,     "comp": 15.0, "known": true },
    "dumpers_sold":    { "value": 5,     "comp": 6.0,  "known": true },
    "ring_holding":    { "value": 1,     "comp": 15.0, "known": true },
    "bundled_pct":     { "value": 45.0,  "comp": 9.2,  "known": true },
    "dev_exit":        { "value": 100.0, "comp": 6.1,  "known": true },
    "wash_pct":        { "value": 27.0,  "comp": 4.3,  "known": true }
  },
  "dev_dump_slot": 434305434,
  "weights": { "dev": 0.35, "offenders": 0.25, "bundle": 0.15, "exit": 0.10, "wash": 0.15 }
}

Signal 2 — repeat offenders: /tokens/{mint}/repeat-offenders

This is the sharpest single question you can ask about a token: which of its current participants have dumped rugs before? The endpoint returns every wallet in this token that previously sold inside a dev's dump slot (same_slot_count = bundled with the dump itself) or in the slots right after, across past rugged tokens — with the role split between as_operator (ran the token) and as_sniper (rode the dump), the SOL extracted, and a seen_in sample of the tokens they dumped:

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

{
  "mint": "9xQm…pump",
  "flagged": 8,
  "this_token": { "rugged": true, "dev_dump_slot": 434305434, "co_dumpers": 36, "same_slot": 1 },
  "data": [
    {
      "wallet": "6hh9…Nfew",
      "rug_count": 1670,
      "same_slot_count": 595,
      "as_operator": 0,
      "as_sniper": 1274,
      "sol_extracted": 14.21,
      "seen_in": ["$Gentlemen", "$Mosquito", "$Groundhog"],
      "seen_in_more": 15,
      "last_seen": "2026-07-21T13:05:11Z"
    }
  ]
}

A wallet with 1,670 rugs and 595 same-slot dumps is not unlucky — it is part of the machine. The this_token block also tells you whether this token has already rugged (rugged, dev_dump_slot, and how many wallets co-dumped). If flagged wallets are present and the trust signal dumpers_holding is non-zero, the dump squad is in position right now.

Signal 3 — the dev's rap sheet: /creators and the dev score

Take the creator field from GET /tokens/{mint} and pull the dev's full card. The dev score is 0–100 (−1 = not yet scored) and is backed by hard counters — rug_events, dev_dump_count, full_exit_count versus held_clean_count, plus launch cadence, graduation rate, wallet age and the sybil graph (sibling_creators, shared_funder_degree):

curl -s -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/creators/5Q5q…Funr/stats"

{
  "creator": "5Q5q…Funr",
  "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,
  "grad_rate": 0.034,
  "dev_dump_count": 23,
  "full_exit_count": 9,
  "held_clean_count": 4,
  "rug_events": 11,
  "survival_rate": 0.080,
  "wallet_age_days": 6.4,
  "funder_kind": "exchange",
  "funder_label": "Binance",
  "sibling_creators": 7, …
}

Eighty-seven tokens, eleven rug events, a wallet less than a week old: that profile answers the question before the chart does. To screen at scale, GET /creators lists every creator with the same stats card — filter with min_tokens to cut one-token spam and min_score / max_score to isolate the dangerous band, or bulk-export the whole set with sort=recent and keyset pagination.

Signal 4 — fake volume: /tokens/{mint}/wash-traders

Rug setups need a crowd, and a crowd can be faked. Wash traders are round-trippers — wallets with at least 5 buys and 5 sells on the same token in the last 24h — whose churn makes the tape look organic. The endpoint flags them and estimates how much of the day's volume is artificial:

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

{
  "mint": "9xQm…pump",
  "window_h": 24,
  "flagged": 6,
  "shown": 6,
  "wash_vol_sol": 128.4,
  "total_vol_sol": 472.9,
  "wash_pct": 27.2,
  "data": [
    { "wallet": "6hh9…Nfew", "buys": 41, "sells": 39, "vol_sol": 88.2 }
  ]
}

A wash_pct above ~20% is a chart you cannot trust — and it feeds straight into the trust score's wash_pct signal. data shows the top 20 round-trippers; flagged is the full count.

Signal 5 — a wallet's full rug history: /wallets/{addr}/dumps

When a specific holder looks dirty, pull its complete record: every rugged token it took part in, one row per token, recent-first and keyset-paginated. Filters: since, min_sol (minimum SOL extracted), same_slot=1 (only dumps in the dev's exact slot), limit (max 500). The first page also carries an all-time summary:

curl -s -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/wallets/8psN…VRtf/dumps?min_sol=0.1&limit=100"

{
  "wallet": "8psN…VRtf",
  "count": 100,
  "data": [
    { "mint": "9xQm…pump", "symbol": "WIF", "token_created_at": "2026-07-20T11:00:00Z",
      "same_slot": true, "as_operator": false, "as_sniper": true, "sol_extracted": 3.42 }
  ],
  "next_cursor": "2026-07-20T11:00:00.482913Z|9xQm…pump",
  "summary": { "total_dumps": 1670, "same_slot": 595, "sol_extracted": 421.7 }
}

Once a wallet is confirmed dirty, watch everything else it touches — the workflow in tracking pump.fun wallets turns one bad actor into an early-warning list for every future launch it enters.

How to avoid rug pulls on pump.fun: the 60-second checklist

Put together, the five signals give you a repeatable way to rug check pump.fun coins before entry:

export RAIDEN_KEY=rdn_…your_key MINT=9xQm…pump

# 1 · the one-number answer — score, verdict, and which signal drags it down
curl -s -H "X-API-Key: $RAIDEN_KEY" "https://terminal.raiden.wtf/api/tokens/$MINT/trust"

# 2 · known rug-dumpers currently in the token
curl -s -H "X-API-Key: $RAIDEN_KEY" "https://terminal.raiden.wtf/api/tokens/$MINT/repeat-offenders?limit=20"

# 3 · the dev's record (creator address comes from GET /tokens/$MINT)
curl -s -H "X-API-Key: $RAIDEN_KEY" "https://terminal.raiden.wtf/api/creators/$CREATOR/stats"

# 4 · how much of the volume is fake
curl -s -H "X-API-Key: $RAIDEN_KEY" "https://terminal.raiden.wtf/api/tokens/$MINT/wash-traders"

# 5 · deep-dive any wallet that came up dirty
curl -s -H "X-API-Key: $RAIDEN_KEY" "https://terminal.raiden.wtf/api/wallets/$WALLET/dumps?min_sol=0.1&limit=100"

• verdict: likely_rug → skip, no discussion.
• capped: true → read cap_reason; the ceiling is there because one hard signal tripped, not as a rounding artifact.
• dumpers_holding > 0 → wallets that dumped past rugs are in position now; dumpers_sold means they already took their exit.
• rug_events > 0 on a days-old dev wallet → serial setup: throwaway creators exist precisely to reset a burned reputation.
• wash_pct high → the activity you are chasing is manufactured.

Script it: trust + repeat offenders in one call

For automation, skip the fan-out: GET /tokens/{mint}/pack returns the whole dossier in one request — trust, repeat_offenders, wash_traders, launch, funding_clusters, holder_stats and more, each key being the exact response of the matching standalone endpoint (or null if that part failed — the pack itself never fails):

import requests

BASE = "https://terminal.raiden.wtf/api"
H = {"X-API-Key": "YOUR_KEY"}

def rug_check(mint):
    pack = requests.get(f"{BASE}/tokens/{mint}/pack", headers=H).json()["pack"]
    trust, ro = pack["trust"], pack["repeat_offenders"]

    cap = f"  (capped: {trust['cap_reason']})" if trust.get("capped") else ""
    print(f"trust {trust['score']}/100 → {trust['verdict']}{cap}")
    for name, s in trust["signals"].items():
        if s["known"]:
            print(f"  {name:16} value={s['value']:8} comp={s['comp']}")

    if ro and ro["flagged"]:
        print(f"{ro['flagged']} repeat offenders currently in the token")
        for w in ro["data"][:5]:
            role = "operator" if w["as_operator"] else "sniper"
            print(f"  {w['wallet'][:6]}  {w['rug_count']} rugs, "
                  f"{w['same_slot_count']} same-slot ({role}) — "
                  f"seen in {', '.join(w['seen_in'][:3])} +{w['seen_in_more']}")

    hard_no = (trust["verdict"] == "likely_rug"
               or trust["signals"]["dumpers_holding"]["value"] >= 3
               or (ro or {}).get("this_token", {}).get("rugged"))
    return "SKIP" if hard_no else "worth a closer look"

print(rug_check("9xQm…pump"))

The thresholds are yours to tune — the point is that every input is a documented field, not a vibe. Sub-calls inside the pack reuse the same cache as the individual endpoints, so the bundle is lighter on the backend than calling them separately. Note the pack covers the token-side signals only — the dev card (/creators/{addr}/stats) and the per-wallet dump history (/wallets/{addr}/dumps) remain their own calls.

Live from current holders — not a cached verdict

The property that makes this usable as a real pump.fun rug checker: everything is computed live at request time from the token's current state. The trust score re-reads the holder set on every call — that is how it can distinguish dumpers_holding (flagged wallets still in position) from dumpers_sold (they already exited), a distinction a cached verdict cannot make and exactly the one that matters in the minutes around a launch. The history behind the signals runs deep too: six months of tick-level retention, complete since May 1, 2026, with amounts returned as strings in lamports (1 SOL = 1e9) wherever raw chain units apply.

The same checks power the token page on Raiden Terminal — same endpoints, same numbers. For the launch-side half of the problem, continue with the pump.fun bundle checker; to monitor the wallets you flag, see tracking pump.fun wallets; and the full endpoint reference with exact response shapes lives at /docs-api.