When a Pump.fun token crosses the bonding curve threshold — currently $69,000 of market cap — it graduates. The bonding curve is closed, a Raydium AMM pool is seeded with the accumulated SOL and remaining tokens, and trading flips from Pump.fun to Raydium. For any bot that touches Pump.fun, detecting this moment correctly is non-negotiable. Miss it and you're trying to swap against a curve that no longer exists; catch it and you can front-run the Raydium liquidity wave.

What Graduation Actually Does On-Chain

Graduation is a sequence of three transactions, usually in the same slot:

Close bonding curve — the Pump.fun program marks the bonding curve account as completed.
Create Raydium pool — a standard Raydium AMM V4 initialize instruction creates the pool with the graduated token as base and wrapped SOL as quote.
Seed liquidity — accumulated SOL and remaining bonding-curve tokens are deposited as initial liquidity, and the LP position is permanently locked.

There's no Pump.fun "on graduation" event you can subscribe to. The signal you're looking for is structural: a transaction where both the Pump.fun program and the Raydium AMM V4 program are invoked together. That's the fingerprint.

The gRPC Filter That Catches It

Subscribe to transactions where both programs appear:

SubscribeRequestFilterTransactions {
  vote: Some(false),
  failed: Some(false),
  account_include: vec![
    PUMP_FUN_PROGRAM.to_string(),
    RAYDIUM_AMM_V4.to_string(),
  ],
  account_required: vec![
    PUMP_FUN_PROGRAM.to_string(),
    RAYDIUM_AMM_V4.to_string(),
  ],
  ..Default::default()
}

account_required is the trick: it forces the transaction to include both programs, not just one or the other. Without it you'd get ~10,000 false positives per day — every Pump.fun buy and every Raydium swap. With it, you get exactly the graduation transactions.

Parsing The Pool Address

Once you have the graduation transaction, you need to extract the newly-created Raydium pool address so your bot can swap against it. The pool address is derived from the Raydium initialize instruction's accounts:

Account index 4: the pool state PDA
Account index 5: base token mint (the graduated token)
Account index 6: quote token mint (wrapped SOL)
Account index 10: base token vault
Account index 11: quote token vault

On Subglow's pre-parsed JSON output, these are already labeled. On raw Yellowstone, you walk the instruction's accounts array by index.

Three Gotchas We Hit The Hard Way

1. LP is locked — don't try to remove liquidity

Pump.fun graduations create Raydium pools with the LP tokens burned. Any bot logic that checks "can I remove liquidity from this pool?" will return a misleading answer. The pool is a one-way ratchet — trades only.

2. First-slot liquidity is thin

The initial deposit is whatever SOL accumulated on the bonding curve (at $69k mcap it's around 85 SOL) plus the remaining bonding-curve tokens. That's not a deep pool. If you try to swap a large amount in the first slot after graduation, your slippage will be brutal. Scale your copy size for the first 10–30 seconds.

3. Pump.fun sometimes relaunches — watch for fake graduations

A handful of times per month we see a Pump.fun transaction that invokes Raydium AMM V4 but isn't a graduation — usually a failed migration that gets retried. Your filter will catch these and they look legitimate until you check the result. Always verify the Raydium pool actually exists after the fact by reading the pool state account.

What Traders Do With This Signal

Three common patterns we see from Subglow users:

Instant buy on graduation. Thesis: a Pump.fun token that made it to graduation has real momentum. The Raydium pool is the first opportunity to swap with a deeper order book, and the first 30–60 seconds of Raydium trading often sees a momentum blowoff top.
Instant sell on graduation. Inverse thesis: the bonding curve holders want out, and the Raydium liquidity is their first chance to sell without crater slippage. Front-run the dump.
Watchlist transition. Your bot was tracking a Pump.fun token on the bonding-curve side. At graduation, switch the watchlist entry to the Raydium pool address so subsequent swaps go through AMM instructions, not bonding-curve instructions.

Which of these is profitable depends on the market regime. In bullish environments, pattern (1) wins. In sideways-to-down environments, pattern (2) wins. Pattern (3) is always correct — it's just bookkeeping.

Putting It Together: A Minimal Listener

Here's a skeleton in TypeScript using the standard Yellowstone client (replace with your Subglow key):

import Client from "@triton-one/yellowstone-grpc";

const client = new Client("grpc.subglow.io:443", "YOUR_API_KEY");
const stream = await client.subscribe();

stream.write({
  slots: {},
  transactions: {
    graduations: {
      vote: false,
      failed: false,
      account_include: [PUMP_FUN_PROGRAM, RAYDIUM_AMM_V4],
      account_required: [PUMP_FUN_PROGRAM, RAYDIUM_AMM_V4],
    },
  },
  accounts: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
});

for await (const msg of stream) {
  if (!msg.transaction) continue;
  const tx = msg.transaction.transaction;
  const poolAccount = extractRaydiumPool(tx); // parse instruction accounts
  console.log("GRADUATION", tx.signature, poolAccount);
  // hand off to your strategy layer
}

On Subglow, replace the Borsh parsing step entirely — the graduation transaction arrives with graduated_mint, raydium_pool, initial_sol, and initial_tokens fields pre-populated.

Pump.fun Graduation Detection: Catching the Raydium Migration in Real Time