Get pump.fun graduated tokens: list, API and real-time alerts

Graduation is the one event in a pump.fun token's life that everybody wants to catch: the bonding curve completes, liquidity migrates to PumpSwap, and the token either becomes a real market or a monument. This guide covers the three jobs around it with the Raiden API: pull the pump.fun graduated tokens list, run a real-time pump.fun graduation tracker over WebSocket, and approximate which tokens are about to graduate before they do.

Why graduation matters

On the bonding curve, price is a deterministic function of reserves and the only counterparty is the curve itself. Graduation ends that: the curve closes and the liquidity moves into a PumpSwap AMM pool. In the token record this is three fields flipping at once — status becomes "graduated", graduated_at timestamps the migration, and amm_pool holds the new pool address, next to the original bonding_curve address that never goes away. The vast majority of launches never get there, which is exactly why the graduated subset is the interesting one: it is the pre-filtered list of tokens that survived their own launch.

Job 1: the pump.fun graduated tokens list

The screener endpoint GET /tokens takes a documented status filter: 0 = still bonding, 1 = graduated. Combine it with sort=newest|last_trade, a from/to window (RFC3339, on created_at), limit up to 500 and keyset pagination via cursor:

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

{
  "data": [
    {
      "mint": "9xQm…pump",
      "creator": "5Q5q…Funr",
      "name": "Example Token",
      "symbol": "EXMPL",
      "decimals": 6,
      "bonding_curve": "Cb3f…g9rE",
      "created_at": "2026-06-21T09:41:14Z",
      "created_slot": 348812944,
      "status": "graduated",
      "graduated_at": "2026-06-21T11:03:52Z",
      "amm_pool": "Gm4w…9xZ2",
      "last_price": "0.00000042",
      "last_trade_at": "2026-06-27T08:12:30Z",
      "vol_1h": "488888889",
      "trades_1h": 1342,
      "traders": 8421,
      "dev_score": 62,
      …
    }
  ],
  "next_cursor": "2026-06-27T08:12:30.123456789Z"
}

Every row is a full token object: metadata, last price, 1-hour volume and trader counts, plus the creator's dev_score and flags. To get graduated pump.fun tokens in bulk — say, every graduation from a launch cohort — pass from/to for the creation window and follow next_cursor until it comes back empty. Keyset pagination means the export is stable under load; the same loop pattern is covered in depth in the historical-data guide.

For a single token you already care about, GET /tokens/{mint} returns the same snapshot — status, graduated_at, amm_pool — in one call.

Job 2: a real-time pump.fun graduation tracker

Polling the list tells you what graduated; a stream tells you the moment it happens. The WebSocket layer has a dedicated grad kind: create a stream with POST /ws-subscriptions and you get an opaque token to connect with. No filters needed — grad pushes every migration:

curl -X POST "https://terminal.raiden.wtf/api/ws-subscriptions" \
  -H "X-API-Key: $RAIDEN_KEY" -H "Content-Type: application/json" \
  -d '{"name":"grads","kinds":["grad"]}'

{
  "id": 3, "token": "sub_a1b2c3…", "name": "grads", "active": true,
  "kinds": ["grad"], …
}

Connect with the API key and the stream's sub token; each pushed event carries a type, and graduations arrive as type: "graduate" with the mint:

wscat -c "wss://terminal.raiden.wtf/ws?key=$RAIDEN_KEY&sub=sub_a1b2c3…"

Streams are capped at 3 per account by default, but one stream can mix kinds — a single connection can carry grad plus creations or a feed of whale trades, so a graduation desk rarely needs more than one.

Job 3: pump.fun tokens about to graduate

There is no "about to graduate" endpoint, because closeness to graduation is not a stored token field — it is the live state of the bonding curve. That state, however, is on every swap row: v_sol_reserves, v_token_reserves, real_sol_reserves and real_token_reserves snapshot the curve after each fill. So the recipe is:

• Screen the active field: /tokens?status=0&sort=last_trade — bonding tokens, most recently traded first.
• For each candidate, read the newest swap: /tokens/{mint}/swaps?order=desc&limit=1.
• Rank by how far real_sol_reserves has climbed — the closer the curve is to completion, the higher the real SOL locked in it and the lower the tokens left in real_token_reserves.

The exact progress formula — what the virtual reserves are, how price falls out of them, and how to turn reserves into a percentage — is its own topic: the bonding-curve progress guide walks through it with the same fields. For alerting, combine this ranking with the grad stream above: the poll finds the shortlist, the push confirms the event.

One script: poll the list, listen for the push

import asyncio, json, requests, websockets

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

# 1 · seed: every graduated token created since July 1 (keyset export)
def graduated_since(frm):
    out, cursor = [], None
    while True:
        p = {"status": 1, "sort": "newest", "limit": 500, "from": frm}
        if cursor:
            p["cursor"] = cursor
        r = requests.get(f"{BASE}/tokens", params=p, headers=H).json()
        out += r["data"]
        cursor = r.get("next_cursor")
        if not cursor:
            break
    return out

seed = graduated_since("2026-07-01T00:00:00Z")
print(f"{len(seed)} graduated tokens in the seed window")

# 2 · live: a grad stream pushes type "graduate" the moment a token migrates
sub = requests.post(f"{BASE}/ws-subscriptions", headers=H,
                    json={"name": "grads", "kinds": ["grad"]}).json()

async def listen():
    url = f"wss://terminal.raiden.wtf/ws?key={KEY}&sub={sub['token']}"
    async with websockets.connect(url) as ws:
        async for msg in ws:
            ev = json.loads(msg)
            if ev.get("type") == "graduate":
                t = requests.get(f"{BASE}/tokens/{ev['mint']}", headers=H).json()
                print(f"GRADUATED {t['symbol']}  pool={t['amm_pool']}  at={t['graduated_at']}")

asyncio.run(listen())

The REST pass gives you the backfilled list; the WebSocket keeps it current without a polling loop. On each push, one /tokens/{mint} call enriches the event with the pool address and the exact graduated_at timestamp.

Graduation in the macro numbers

These are the denominators: a graduation tracker without the hourly grad_rate next to it will happily celebrate a day when everything is graduating — including the exit liquidity.

The dataset behind all of this keeps six months of rolling tick-level retention — at the time of writing, the complete record since May 1, 2026. Full request and response shapes for every endpoint used here are in the API docs; keys are invite-only via the Raiden pump.fun API page. To act on a graduation the moment it lands, wire the grad kind into your existing streams with the WebSocket guide — and to front-run the event rather than react to it, start from bonding-curve progress.