RAIDEN Get pump.fun graduated tokens: list, API and real-time alerts
Get the pump.fun graduated tokens list via API: status filter, bulk export, WebSocket graduation alerts, and how to spot tokens about to graduate.
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.
Continuity: the mint address does not change at graduation,
and every swap row carries a
venue tag identifying the program that
executed the fill. Pre-curve and post-migration trades live in the same series — one
tape, one candle history, no reset.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.
Window semantics:
from/to range
on created_at, not graduated_at. A token created in June can
graduate in July — if you need every graduation in a wall-clock window regardless of
launch date, widen the creation window and filter client-side on
graduated_at.
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_reserveshas climbed — the closer the curve is to completion, the higher the real SOL locked in it and the lower the tokens left inreal_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.
Units: reserve and amount fields are JSON strings to keep
64-bit precision intact — SOL-side values in lamports (1 SOL = 1e9), token-side values
in the token's base units. Parse with integers, not floats.
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
| Endpoint | What it adds |
|---|---|
/pump-24h | graduated vs graduated_prev — the last 24h against the 24h before |
/aggregates/pulse-history | Hourly time-series of graduations and grad_rate next to new tokens and volume |
/events | Notable-events feed — graduations alongside big trades |
/stats | tokens_graduated — the all-time indexed count |
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 free, with 200,000 trial credits, 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.
Frequently asked questions · 6 answers
What does it mean when a pump.fun token graduates?
The bonding curve is complete: trading leaves the curve and liquidity migrates to a PumpSwap AMM pool. In the API the token's status flips to graduated, graduated_at records the moment, and amm_pool holds the new pool address — while the original bonding_curve address stays on the record.
How do I get a list of graduated pump.fun tokens?
Call GET /tokens with status=1. Each row carries status, graduated_at and amm_pool next to price and volume stats. Sort by newest or last_trade, page with the keyset cursor (limit up to 500 per page) and narrow the window with from/to on the creation date.
How do I get real-time pump.fun graduation alerts?
Create a WebSocket stream with kinds ["grad"] via POST /ws-subscriptions, then connect to wss://terminal.raiden.wtf/ws with your API key and the stream's sub token. The stream pushes a type:graduate event when a token migrates to PumpSwap — no polling loop needed.
How can I find pump.fun tokens about to graduate?
There is no dedicated endpoint, but every swap row reports the bonding curve's reserve state (v_sol_reserves, real_sol_reserves and friends). Screen active bonding tokens with status=0 and sort=last_trade, read each candidate's latest swap, and rank by how far the real SOL reserves have climbed. The bonding-curve progress guide covers the exact math.
Does a token's trade history reset when it graduates?
No. The mint address stays the same, and every swap row carries a venue tag identifying the program that executed the fill, so swaps and candles form one continuous series across the migration from the bonding curve to PumpSwap.
How much graduated-token history does the API keep?
Six months of rolling tick-level retention — at the time of writing, the complete record since May 1, 2026. Token-level fields like status, graduated_at and amm_pool are part of the token record itself, so the graduated list covers everything indexed.
Build on the same data
Free API key with 200,000 trial credits: full REST and WebSocket access to the same firehose that powers the Terminal. Connect a Solana wallet; no email, no card.
Raiden TerminalGuides
Pump.fun API
Ingested by Raiden Vortex
© Raiden · an independent Solana data provider, not affiliated with pump.fun