Pons Launchpad API: Track Token Launches and Graduations in Real Time

Short answer: subscribe to launches:pons and graduations:pons on the Crius WebSocket stream to hear about every Pons launch and graduation the moment it is indexed, then call GET /v1/robinhood/token/{address}/launch for the full lifecycle: creator, curve, progress, fees and the Uniswap v4 pool it graduated into. For lists rather than events, GET /v1/robinhood/tokens?launchpad=pons&list=new|bonding|graduating|graduated gives you sorted, filterable snapshots with no API key required.

Pons is the busiest launchpad on Robinhood Chain, which makes it both the most interesting and the noisiest place to watch. This guide covers how a Pons token moves from launch to graduation, which parts of that you can observe, and how to build a tracker that keeps up with it. Every request and response below was run against the live API in October 2026.

Pons in numbers

At time of writing (October 24, 2026), the launchpads endpoint reports for Pons:

Two things stand out. Almost every Pons launch stays on its bonding curve forever: fewer than 1.5 in 100 graduate. And the ones that do graduate usually do it fast, often within minutes. A useful tracker therefore has to be cheap per launch (most are noise) and fast on the few that matter.

curl -s "https://api.crius.sh/v1/robinhood/launchpads" | jq '.data[] | select(.id == "pons") | .stats'

{
  "graduated": 10428,
  "graduated_24h": 13,
  "graduation_rate_pct": 1.46888,
  "launches_24h": 1345,
  "median_blocks_to_graduate": 2479,
  "tokens_launched": 709929,
  "volume_usd_24h": 17641427
}

The same response lists the Pons contracts Crius watches (factory 0x7ed5…ec7e, the PonsV2MemeHook at 0xe5e7…e044, the LP locker and the fee escrow), so you can cross-check anything against the chain yourself.

How a Pons token moves from launch to Uniswap v4

Pons V2, live since August 2026, works like this:

1. Launch. A creator calls the factory (or the launch-and-buy contract, which also makes the first purchase in the same transaction). The factory mints a fixed supply of 1,000,000,000 tokens into a dedicated bonding curve contract.
2. Bonding. Everyone trades against the curve in ETH. Each buy raises the price and moves the curve toward its graduation threshold, which is 4.2 ETH raised for ETH-quoted launches.
3. Graduation. When the curve reaches the threshold, Pons moves the raised ETH and a slice of the supply into a Uniswap v4 pool that uses the PonsV2MemeHook, and the liquidity position is locked permanently in the Pons LP locker.
4. DEX trading. From then on the token trades on Uniswap v4 like any other token, with the hook collecting fees for the creator and the protocol.

Crius indexes every step, so you never need to decode the factory calldata or follow the migration yourself.

The launch lifecycle endpoint

GET /v1/robinhood/token/{address}/launch (Free plan, 2 credits) returns the whole story of one token. Here is a token that was still on its curve at time of writing, trimmed:

curl -s "https://api.crius.sh/v1/robinhood/token/0x4fda1b2ab3cc83bcb5525811d43018497a4f1f50/launch" \
  -H "x-api-key: $CRIUS_API_KEY"

{
  "launchpad": "pons",
  "status": "bonding",
  "creator": "0xa6067b80b4b592716d30562dc1b51864893d42a0",
  "curve": "0x642dd17359bac842c00baeb9e5566a4e0a722080",
  "launched_block": 96710587,
  "launched_via": "factory",
  "pair_token": { "address": "0x0000000000000000000000000000000000000000", "symbol": "ETH" },
  "progress": { "pct": 85.4924, "raised": 3.5906794311729366, "threshold": 4.2 },
  "curve_stats": { "buys": 72, "sells": 15, "unique_traders": 37, "volume_quote": 3.994, "history": "complete" },
  "fees": {
    "hook_fee_bps": 100,
    "protocol_fee_share_bps": 3000,
    "creator_tax_bps": 0,
    "snipe_tax": { "start_bps": 9900, "window_s": 3 }
  },
  "graduation": null
}

And a token that graduated:

{
  "launchpad": "pons",
  "status": "graduated",
  "progress": { "pct": 100, "raised": 4.2, "threshold": 4.2 },
  "graduation": {
    "block": 96336149,
    "blocks_to_graduate": 157564,
    "pool": "0xa2ea57736f42ab196dde7f9ba3c91f9e29839c76c20e130fa3e4d2e0de787ab5",
    "quote_to_pool": 4.2,
    "tokens_to_pool": 204081632.65306124,
    "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952",
    "lp_position_id": 3979324
  }
}

The fields that matter most:

• status: bonding or graduated.
• progress.pct, raised and threshold: how far along the curve is, in the curve’s quote asset. Progress is raised / threshold.
• graduation.pool: the Uniswap v4 pool id the token moved into. Feed it to /pool/{pool} for live reserves, the hook and the lock status.
• graduation.quote_to_pool and tokens_to_pool: what seeded the pool. Here 4.2 ETH and about 204 million tokens (20.4% of supply).
• fees: the token’s live fee configuration, read from the chain. The hook takes 1% of each trade (hook_fee_bps: 100), of which the protocol keeps 30% (protocol_fee_share_bps: 3000). The creator can add a creator tax, and new launches start with a snipe tax that begins at 99% for the first 3 seconds.

For the full fee picture after launch, see How to Monitor Launchpad Creator Fees and Revenue.

Lists: what’s new, bonding, graduating and graduated

GET /v1/robinhood/tokens returns sorted lists and works without a key at the anonymous rate limit. Combine launchpad=pons with a list:

# Just launched
curl -s "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=20"

# Still on the curve, closest to graduating first
curl -s "https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons&limit=20"

# Recently graduated
curl -s "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=pons&limit=20"

Each item carries price, market cap, liquidity, holders, windowed buy and sell volume, progress_pct and status. A trimmed item from the graduating list:

{
  "address": "0x45a4f7a5e9eb2e376b7d2e64aa8074fd7f7c3fb0",
  "symbol": "VST",
  "launchpad": "pons",
  "status": "bonding",
  "progress_pct": 88.0182,
  "market_cap_usd": 40711.8,
  "liquidity_usd": 17492.2,
  "holders": 25,
  "created_ts": 1792771139600
}

Filter the noise with min_liquidity_usd, min_volume_usd and created_after_ts, and page with cursor. If you need the same lists across every launchpad, drop the launchpad parameter, or use flap, bankr, long or standard_reserve (King of the Markets) instead.

Real time: the launch and graduation streams

Polling is fine for dashboards. For anything that reacts, use the WebSocket stream. The two channels you need:

launches:all and graduations:all cover every supported launchpad, and dev:<address> follows a single creator. A real launch message, as received:

{
  "ch": "launches:pons",
  "seq": 9,
  "block": 96713680,
  "ts": 1792839603000,
  "data": {
    "address": "0x74ee1bad4aac06e4f557e4f6eb73fb1536161f0b",
    "creator": "0x2317da62fd7dfa68ee4a4ecb35d7bde647889213",
    "curve": "0x8a3bfc73d639a683b7cc89bfdcd9a67b6a66d9f4",
    "launchpad": "pons",
    "quote": "ETH",
    "tx": "0xcdf1a80de8501048344fed4d6360deed6c9e150d9acc2064947f7ffdf2aa4c82"
  }
}

A complete Pons tracker in Node.js

This tracker listens for launches and graduations, enriches each graduation with the lifecycle endpoint, and keeps the last sequence number per channel so a reconnect can resume without gaps. It runs on Node.js 22 or later (built-in WebSocket and fetch).

// pons-tracker.mjs: node pons-tracker.mjs
const API = "https://api.crius.sh/v1/robinhood";
const KEY = process.env.CRIUS_API_KEY;
const headers = { "x-api-key": KEY };
const CHANNELS = ["launches:pons", "graduations:pons"];
const lastSeq = {}; // channel -> last seq seen, for resume

async function onGraduation(g) {
  const r = await fetch(`${API}/token/${g.token}/launch`, { headers });
  const { data } = await r.json();
  const minutes = ((data.graduation.blocks_to_graduate * 0.1) / 60).toFixed(1);
  console.log(`GRADUATED ${g.token} in ~${minutes} min, pool ${g.pool}`,
    `traders ${data.curve_stats.unique_traders}, creator tax ${data.fees.creator_tax_bps} bps`);
}

function connect() {
  const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`);
  ws.onopen = () => {
    // Subscribe first; then, after a reconnect, ask for what was missed on those channels.
    ws.send(JSON.stringify({ op: "subscribe", channels: CHANNELS }));
    if (Object.keys(lastSeq).length > 0) ws.send(JSON.stringify({ op: "resume", seqs: lastSeq }));
  };
  ws.onmessage = (e) => {
    const m = JSON.parse(e.data);
    if (!CHANNELS.includes(m.ch)) return; // hello, subscribed, heartbeat
    lastSeq[m.ch] = m.seq;
    if (m.ch === "launches:pons") console.log(`launch ${m.data.address} by ${m.data.creator} (block ${m.block})`);
    if (m.ch === "graduations:pons") onGraduation(m.data).catch((err) => console.error(err.message));
  };
  ws.onclose = () => setTimeout(connect, 2000);
}
connect();

Run against the live stream, it printed launches within a second or two of the block:

launch 0x74ee1bad4aac06e4f557e4f6eb73fb1536161f0b by 0x2317da62fd7dfa68ee4a4ecb35d7bde647889213 (block 96713680)

Graduations are rarer (13 in the 24 hours before writing), so leave it running. The resume buffer covers 60 seconds, which is plenty for a normal reconnect; after a longer outage, backfill from the graduated list.

The same tracker in Python, using the websockets package:

import asyncio, json, os, websockets

URL = f"wss://api.crius.sh/v1/robinhood/stream?api_key={os.environ['CRIUS_API_KEY']}"

async def main():
    async with websockets.connect(URL) as ws:
        await ws.send(json.dumps({"op": "subscribe", "channels": ["launches:pons", "graduations:pons"]}))
        async for raw in ws:
            m = json.loads(raw)
            if m.get("ch") == "launches:pons":
                print("launch", m["data"]["address"], "by", m["data"]["creator"])
            elif m.get("ch") == "graduations:pons":
                print("graduated", m["data"]["token"], "into", m["data"]["pool"])

asyncio.run(main())

Vetting a fresh launch

A launch event tells you a token exists, not whether it is worth anything. Before acting on one, check:

• The creator’s history. /dev/{address} lists every token the creator launched, how many graduated, the best and median peak market caps, how much of each token the creator sold, and who funded the wallet. A creator with 40 launches and no graduations is a pattern.
• Early buyers. /bundles shows wallets that bought in the first blocks, coordinated bundles and funding clusters, and how much supply they hold. See Detect Token Bundles, Sniper Wallets and Connected Holders.
• Concentration and tax. The token profile reports holder concentration, and /security measures the tax actually paid on real buys and sells.

After graduation

Nothing changes in your code. Candles include the bonding-curve history by default and continue on the Uniswap v4 pool, the trade tape covers both venues, and the token’s price switches to the pool automatically. To watch the new pool’s liquidity, subscribe to lp:<token>; to follow the price, price:<token> or candles:<token>:1m.

FAQ

Is there a free Pons API? Yes. The launchpad stats and the token lists (/tokens?launchpad=pons) work without a key at 2 requests per second, and the Free plan (1,000,000 credits a month, 10 requests per second, one WebSocket connection) covers the lifecycle endpoint and the launch and graduation streams.

How fast do launch events arrive? Launch and graduation messages are pushed as soon as the block is indexed, typically within a second or two of the block on Robinhood Chain’s ~100 ms blocks.

What is the Pons graduation threshold? For ETH-quoted launches it is 4.2 ETH raised on the curve; the exact threshold for every token is in the /launch response. At graduation the raised ETH and about 20% of the supply seed a Uniswap v4 pool, and the LP position is locked permanently.

Can I get every Pons token ever launched? Yes. Crius indexed Robinhood Chain from block one, and the lists page through all of them. For bulk historical work, use historical data or contact support@crius.sh.

Does this work for other launchpads? Yes. The same endpoints and channels cover Flap.sh, Bankr, Long.xyz and King of the Markets; see the launchpads API and the Flap.sh API.

Related

• Pons API and Launchpads API
• Track Pons Bonding Curve Progress With an API
• How to Monitor Launchpad Creator Fees and Revenue
• Robinhood Chain WebSocket API: Live Trades, Prices and Reconnects
• Comparing providers for launchpad data: Crius vs Bitquery and all comparisons
• Reference: launch lifecycle, token lists, stream channels

Sources

• The Defiant: Uniswap’s new launchpad out-launched Pons on its first day on Robinhood Chain
• Crypto Briefing: Pons surpasses $6B in all-time Uniswap v4 hook volume
• Datawallet: Pons explained
• Pons contract addresses, fee settings and statistics: Crius API, read from Robinhood Chain (chain id 4663) on October 24, 2026.