Track new pump.fun token launches the second they happen

Every pump.fun strategy — sniping, copy-trading, dev-hunting, or a plain dashboard — starts with the same primitive: seeing the launch. Thousands of new tokens hit pump.fun every day, and how you consume that firehose decides whether you are analyzing the market or screenshotting it. This guide covers the three tiers of tracking new pump.fun token launches on the Raiden API: polling the screener, WebSocket push at creation, and a one-call enrichment that risk-scores a mint before it is a minute old.

Three tiers, one pipeline

They stack: push tells you a token exists, enrich tells you whether it matters, and the poll tier backfills anything you missed while your process was down.

Tier 1 — poll the screener

The /tokens screener sorted by newest is the simplest way to see recent launches — every row is a full token snapshot with the creator, creation slot, bonding status and live price:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/tokens?sort=newest&limit=100"

{
  "data": [
    {
      "mint": "9xQm…pump",
      "creator": "5Q5q…Funr",
      "name": "Example Token",
      "symbol": "EXMPL",
      "created_at": "2026-07-24T09:41:14Z",
      "created_slot": 348812944,
      "status": "bonding",
      "last_price": "0.00000042",
      "dev_score": 62,
      "dev_flags": ["bundle_dev", "sibling_cluster"],
      "dev_funder": "Coinbase"
    }
  ],
  "next_cursor": "2026-07-24T09:41:14.123456789Z"
}

• Keyset pagination: pass next_cursor back as cursor until it comes back empty — no offsets, no missed rows while new tokens keep arriving.
• Window export: from/to (RFC3339) bound the created_at range, so "every launch between 02:00 and 03:00" is one paginated query. limit goes up to 500 per page.
• Risk pre-read for free: screener rows already carry dev_score, dev_flags and dev_funder — a first cut on the creator before you spend a single extra call.
• History: a 6-month rolling window, with a complete record since May 1, 2026.

Tier 2 — push: every launch, at creation

The creations stream kind pushes an event the moment a token is minted. Create a stream over REST — omit dev_list_id and you receive ALL new tokens:

curl -X POST -H "X-API-Key: $RAIDEN_KEY" \
  -d '{"name":"launch-sniffer","kinds":["creations"]}' \
  "https://terminal.raiden.wtf/api/ws-subscriptions"

{ "id": 3, "token": "sub_a1b2c3…", "name": "launch-sniffer",
  "active": true, "kinds": ["creations"], "dev_list_id": "" }

Connect to the opaque token over WebSocket (wss://terminal.raiden.wtf/ws?key=…&sub=sub_…) and each launch arrives as an event with type: "token" — matched server-side, so your client sees nothing else. Accounts get 3 streams by default, and a PUT can flip active to pause one without deleting it. The WebSocket guide covers the full stream lifecycle and the other kinds.

Tier 3 — enrich: the sixty-second risk read

A pushed event is deliberately thin — a token exists, here is the mint. Everything else is one call away: /tokens/{mint}/pack returns the whole token dossier in a single request instead of fanning out nine, and each key under pack is the exact response of the matching standalone endpoint (or null if that part failed — the pack itself never fails):

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

{
  "mint": "9xQm…pump",
  "as_of": "2026-07-24T10:02:00Z",
  "pack": {
    "trust":            { "score": 45, "verdict": "caution",
                          "capped": true, "cap_reason": "bundled", … },
    "launch":           { "bundled_pct_supply": 52.0,
                          "dev_bundle_pct_supply": 11.8, "bundle_count": 3, … },
    "funding_clusters": { "early_buyers": 500, "clustered": 22, … },
    "token": …, "activity": …, "holder_stats": …,
    "smart": …, "repeat_offenders": …, "wash_traders": …
  }
}

Three keys do most of the launch-filtering work:

• trust — the Raiden Trust score, 0–100 (higher = safer), computed live from current holders. The verdict is clean (≥65), caution (40–64) or likely_rug (<40). One hard signal can force the ceiling down regardless of everything else: bundled supply ≥50% caps the score at 45, ≥55% at 35, ≥70% at 25; wash trading at ≥40% of volume caps it at 45 — capped/cap_reason tell you when that happened.
• launch — the first swaps grouped into bundles: bundled_pct_supply, the dev's own bundle share, and every bundled wallet. The mechanics are dissected in the bundle checker guide.
• funding_clusters — early buyers grouped by shared origin-funder, with is_dev marking clusters funded by the dev wallet itself: insiders positioned before you ever saw the ticker.

The complete launch sniffer in Python

Everything wired together: listen for creations, enrich each mint, and apply a simple filter — skip likely_rug verdicts and anything with more launch-bundled supply than you tolerate:

import asyncio, json, requests, websockets

API = "https://terminal.raiden.wtf/api"
H = {"X-API-Key": "YOUR_KEY"}
WS = "wss://terminal.raiden.wtf/ws?key=YOUR_KEY&sub=sub_a1b2c3…"

MAX_BUNDLED = 30.0  # your tolerance for launch-bundled supply, in %

def enrich(mint):
    pack = requests.get(f"{API}/tokens/{mint}/pack", headers=H, timeout=10).json()["pack"]
    trust  = pack.get("trust") or {}
    launch = pack.get("launch") or {}
    fund   = pack.get("funding_clusters") or {}

    verdict = trust.get("verdict", "unknown")
    bundled = launch.get("bundled_pct_supply") or 0.0

    if verdict == "likely_rug":
        return f"SKIP  {mint[:6]}  trust={trust.get('score')} ({verdict})"
    if bundled > MAX_BUNDLED:
        return f"SKIP  {mint[:6]}  bundled={bundled:.1f}% of supply"
    return (f"WATCH {mint[:6]}  trust={trust.get('score')} ({verdict})  "
            f"bundled={bundled:.1f}%  clustered_buyers={fund.get('clustered', 0)}")

async def main():
    async with websockets.connect(WS) as ws:
        async for raw in ws:
            ev = json.loads(raw)
            if ev.get("type") != "token":
                continue
            # enrich off the event loop so the socket keeps draining
            print(await asyncio.to_thread(enrich, ev["mint"]))

asyncio.run(main())

The pack's sub-calls reuse the same cache as the individual endpoints, so this is lighter on the backend than fanning out yourself — and the whole verdict lands while the token is still seconds old. MAX_BUNDLED is your threshold, not the system's; tune it to your risk appetite (remember the trust score already hard-caps at 50% bundled).

Only the big ones: whale flow and notable events

If "every launch" is too much firehose, two narrower taps exist. The feed stream kind pushes only trades at or above a SOL threshold — min_sol, in lamports, default 3000000000 (3 SOL — 1e9 lamports = 1 SOL). It covers every token, not just fresh mints, but add it to your stream's kinds and whale-sized entries on brand-new tokens surface themselves, without you screening thousands of micro-launches. The REST counterpart is the notable-events feed:

curl -H "X-API-Key: $RAIDEN_KEY" \
  "https://terminal.raiden.wtf/api/events?min_sol=3000000000&limit=50"

{ "data": [ { "kind": "trade", "time": "2026-07-24T09:41:14Z",
  "mint": "9xQm…pump", "symbol": "WIF", "actor": "8psN…VRtf",
  "is_buy": true, "sol_amount": "4250000000" } ] }

— big trades at or above your min_sol plus graduations, in one poll-friendly list.

What NOT to do

Do not wire the sniffer to a buy button. Seeing every launch first feels like an edge; it is only the entry ticket. The overwhelming majority of pump.fun tokens never graduate, and a large share are bundled at creation precisely so that early "demand" — the thing an auto-buyer reacts to — can be dumped on it minutes later. The data on how that plays out, launch after launch, is the subject of why pump.fun tokens dump right after launch — read it before automating anything.

The pattern that survives contact with the market is the one this guide builds: push for awareness, enrich for judgment, and a dev-list-filtered stream once you know which creators are worth your latency. Full endpoint and stream reference in the API docs — and if you don't have a key yet, the Raiden API page explains how access works during the private beta.