> ## Documentation Index
> Fetch the complete documentation index at: https://docs.codex.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Launchpad Lifecycle

> Understand how tokens progress through launchpad stages — from creation to bonding curve to graduation and migration.

Launchpad tokens go through a series of stages before they become fully tradeable on a DEX. This guide explains each stage, how to detect them with the Codex API, and which events fire along the way.

This complements the [Launchpads recipe](https://docs.codex.io/recipes/launchpads.md) which covers building a launchpad discovery UI.

## The Stages

Tokens on bonding-curve launchpads (Pump.fun, Four.meme, LaunchLab, etc.) progress through these stages:

```
Deployed → Created → Bonding (Updated) → Completed → Migrated
```

| Stage | What's happening | Key fields |
| - | - | - |
| **Deployed** | Token contract discovered on-chain | `eventType: Deployed` |
| **Created** | Metadata populated (name, symbol, image) | `eventType: Created` |
| **Bonding** | Trading on bonding curve, `graduationPercent` rising from 0→100 | `eventType: Updated`, `graduationPercent < 100` |
| **Completed** | Bonding curve filled — waiting for migration | `completed: true`, `migrated: false` |
| **Migrated** | Liquidity moved to DEX pool — fully tradeable | `migrated: true`, `migratedPoolAddress` set |

> [!NOTE]
>
> **Completed vs Migrated:** `completed` means the bonding curve is full. `migrated` means liquidity has actually moved to a DEX. For monitoring graduations via subscriptions, use `Migrated` events — `Completed` events are a legacy state and will be deprecated.

> [!WARNING]
>
> **Not all launchpads have bonding curves.** Protocols like Zora, Clanker, and Baseapp skip the bonding curve entirely. Tokens on these protocols go straight to "Created" without progressing through completion or migration. Fields like `graduationPercent`, `completed`, `migrated`, and `migratedAt` will be absent for these tokens. Doppler-based protocols (like Bankr) are a related case. They manage liquidity along ticks on Uniswap pools rather than progressing through a traditional bonding curve, so `graduationPercent`, `completed`, and `completedAt` will be null. Migration is still tracked when it occurs, but is rare in practice.

## Detecting Token State

Use the `launchpad` field on the `token` query to check a token's current lifecycle stage.

> [accordion] Check a token's launchpad state
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> query LaunchpadState {
>   token(
>     input: {
>       address: "TOKEN_ADDRESS"
>       networkId: 1399811149
>     }
>   ) {
>     name
>     symbol
>     launchpad {
>       launchpadName
>       launchpadProtocol
>       graduationPercent
>       poolAddress
>       completed
>       completedAt
>       migrated
>       migratedAt
>       migratedPoolAddress
>     }
>   }
> }
> ```

Use this logic to determine the current stage:

```js theme={null}
function getTokenStage(launchpad) {
  if (!launchpad) return 'not-a-launchpad-token'
  if (launchpad.migrated) return 'migrated'
  if (launchpad.completed) return 'completed'
  if (launchpad.graduationPercent > 0) return 'bonding'
  return 'new'
}
```

## Filtering by Stage

Use `filterTokens` with launchpad filters to query tokens at each stage. These are the same filters that power the columns in the [Launchpads recipe](https://docs.codex.io/recipes/launchpads.md).

> [accordion] Tokens currently bonding (not yet graduated)
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> query BondingTokens {
>   filterTokens(
>     filters: {
>       launchpadCompleted: false
>       launchpadMigrated: false
>       launchpadGraduationPercent: { gt: 0 }
>     }
>     rankings: [{ attribute: graduationPercent, direction: DESC }]
>     limit: 10
>   ) {
>     results {
>       createdAt
>       marketCap
>       priceUSD
>       token {
>         name
>         symbol
>         address
>         networkId
>         launchpad {
>           launchpadName
>           graduationPercent
>           completed
>           migrated
>         }
>       }
>     }
>   }
> }
> ```

> [accordion] Recently migrated (graduated) tokens
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> query RecentlyMigrated {
>   filterTokens(
>     filters: { launchpadMigrated: true }
>     rankings: [{ attribute: launchpadMigratedAt, direction: DESC }]
>     limit: 10
>   ) {
>     results {
>       createdAt
>       marketCap
>       priceUSD
>       token {
>         name
>         symbol
>         address
>         networkId
>         launchpad {
>           launchpadName
>           graduationPercent
>           migrated
>           migratedAt
>           migratedPoolAddress
>         }
>       }
>     }
>   }
> }
> ```

> [accordion] Filter by specific launchpad
>
> Use `launchpadName` or `launchpadProtocol` to narrow down to a specific launchpad.
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> query PumpFunTokens {
>   filterTokens(
>     filters: {
>       launchpadName: ["Pump.fun"]
>       launchpadCompleted: false
>       launchpadMigrated: false
>     }
>     rankings: [{ attribute: createdAt, direction: DESC }]
>     limit: 10
>   ) {
>     results {
>       createdAt
>       marketCap
>       priceUSD
>       token {
>         name
>         symbol
>         address
>         networkId
>         launchpad {
>           launchpadName
>           launchpadProtocol
>           graduationPercent
>         }
>       }
>     }
>   }
> }
> ```

> [!TIP]
>
> For the complete list of supported launchpads with their `launchpadName` and `protocol` filter values, see [Supported Launchpads](https://docs.codex.io/launchpads.md).

## Real-Time Lifecycle Events

Subscribe to `onLaunchpadTokenEventBatch` to receive events as tokens progress through each stage. Filter by `eventType` to listen for specific transitions.

> [accordion] New token creations
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> subscription NewLaunchpadTokens {
>   onLaunchpadTokenEventBatch(input: { eventType: Created }) {
>     eventType
>     address
>     networkId
>     launchpadName
>     marketCap
>     price
>     holders
>     token {
>       name
>       symbol
>       address
>       networkId
>       createdAt
>       launchpad {
>         graduationPercent
>         poolAddress
>       }
>     }
>   }
> }
> ```

> [accordion] Token stat updates (bonding curve activity)
>
> `Updated` events fire as tokens trade on the bonding curve. These include statistics like price, volume, and holder counts — fields that aren't available on `Created` or `Migrated` events.
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> subscription BondingCurveUpdates {
>   onLaunchpadTokenEventBatch(input: { eventType: Updated }) {
>     eventType
>     address
>     networkId
>     launchpadName
>     marketCap
>     price
>     holders
>     volume1
>     buyCount1
>     sellCount1
>     sniperCount
>     sniperHeldPercentage
>     bundlerCount
>     bundlerHeldPercentage
>     devHeldPercentage
>     top10HoldersPercent
>     token {
>       name
>       symbol
>       launchpad {
>         graduationPercent
>       }
>     }
>   }
> }
> ```

> [accordion] Token graduations (migrations)
>
> Subscribe to `Migrated` events to detect when a token graduates from its bonding curve and moves to a DEX pool.
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> subscription TokenGraduations {
>   onLaunchpadTokenEventBatch(input: { eventType: Migrated }) {
>     eventType
>     address
>     networkId
>     launchpadName
>     marketCap
>     price
>     liquidity
>     token {
>       name
>       symbol
>       address
>       networkId
>       launchpad {
>         graduationPercent
>         migrated
>         migratedAt
>         migratedPoolAddress
>       }
>     }
>   }
> }
> ```

> [accordion] Track a specific token's lifecycle
>
> Use `onLaunchpadTokenEvent` with an `address` to follow a single token through all its stages.
>
> [Test this query in the Explorer →](https://docs.codex.io/explore.md)
>
> ```graphql theme={null} theme={null}
> subscription TrackToken {
>   onLaunchpadTokenEvent(
>     input: {
>       address: "TOKEN_ADDRESS"
>       networkId: 1399811149
>     }
>   ) {
>     eventType
>     marketCap
>     price
>     holders
>     token {
>       name
>       symbol
>       launchpad {
>         graduationPercent
>         completed
>         migrated
>         migratedAt
>         migratedPoolAddress
>       }
>     }
>   }
> }
> ```

> [!WARNING]
>
> Launchpad events are extremely high-frequency. You must proxy this data through your backend to serve multiple users from a single subscription. We offer a monthly flat-rate option with unlimited requests. [Contact us](mailto:hello@codex.io?subject=Launchpad%20Events%20Subscription) for more information.

## Event Types Reference

| Event Type | When it fires | Stats available? |
| - | - | - |
| `Deployed` | Token contract discovered on-chain | No |
| `Created` | Token metadata populated | No |
| `Updated` | Token stats change (trades, price, holders) | Yes — price, volume, holders, sniper/bundler counts |
| `Completed` | Bonding curve filled (legacy — use `Migrated`) | No |
| `Migrated` | Liquidity moved to DEX pool | No |
| `UnconfirmedDeployed` | Token discovered before finalization | No |
| `UnconfirmedMetadata` | Metadata processed before finalization | No |

> [!NOTE]
>
> Statistics fields (`price`, `volume1`, `holders`, `sniperCount`, etc.) are only populated on `Updated` events. Other event types signal a state change but don't include these metrics.

## After Migration

Once a token migrates, it behaves like any other DEX token. You can switch from launchpad subscriptions to the standard Codex endpoints:

| Data | Endpoint |
| - | - |
| Price & volume | [`pairMetadata`](https://docs.codex.io/api-reference/queries/pairmetadata) using the `migratedPoolAddress` |
| Live price | [`onPairMetadataUpdated`](https://docs.codex.io/api-reference/subscriptions/onpairmetadataupdated) |
| Trades | [`getTokenEvents`](https://docs.codex.io/api-reference/queries/gettokenevents) |
| Live trades | [`onTokenEventsCreated`](https://docs.codex.io/api-reference/subscriptions/ontokeneventscreated) |
| Chart | [`getTokenBars`](https://docs.codex.io/api-reference/queries/gettokenbars) |
| Live chart | [`onTokenBarsUpdated`](https://docs.codex.io/api-reference/subscriptions/ontokenbarsupdated) |

See the [Detailed Token Page recipe](https://docs.codex.io/recipes/detailed-token-page.md) for the full post-migration data flow.

## Protocols Without Bonding Curves

Some launchpad protocols don't use bonding curves. Tokens on these protocols are created and immediately tradeable — they skip the bonding, completed, and migrated stages entirely.

| Protocol | Has bonding curve? |
| - | - |
| Pump.fun | Yes |
| Four.meme | Yes |
| LaunchLab | Yes |
| Meteora DBC | Yes |
| boop.fun | Yes |
| Zora | No |
| Clanker | No |
| Baseapp | No |
| Virtuals | No |

For tokens without bonding curves, the `launchpad` fields `graduationPercent`, `completed`, `completedAt`, `migrated`, `migratedAt`, and `migratedPoolAddress` will be absent. These tokens will only emit `Created` and `Updated` events.

Check out the related endpoints and types:

* [filterTokens](https://docs.codex.io/api-reference/queries/filtertokens.md) — query tokens by launchpad stage
* [token](https://docs.codex.io/api-reference/queries/token.md) — get a token's launchpad data
* [onLaunchpadTokenEvent](https://docs.codex.io/api-reference/subscriptions/onlaunchpadtokenevent.md) — single token lifecycle events
* [onLaunchpadTokenEventBatch](https://docs.codex.io/api-reference/subscriptions/onlaunchpadtokeneventbatch.md) — batched lifecycle events
* [LaunchpadTokenProtocol](https://docs.codex.io/api-reference/enums/launchpadtokenprotocol.md) — supported protocols
* [Launchpads recipe](https://docs.codex.io/recipes/launchpads.md) — building a launchpad discovery UI


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.