# Pump.fun New Tokens & Graduations Feed - Solana On-Chain (`offgrid-labs/pumpfun-launch-graduation-feed`) Actor

Pump.fun new tokens and graduations feed decoded from Solana on-chain data: creator wallet, dev initial buy, bundled buyers, bonding-curve progress, market cap, PumpSwap pool and liquidity. Built in Rust. Bring your own RPC. $2.00 per 1,000 launches.

- **URL**: https://apify.com/offgrid-labs/pumpfun-launch-graduation-feed.md
- **Developed by:** [OFFGRID LABS](https://apify.com/offgrid-labs) (community)
- **Categories:** Developer tools, Automation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 token launches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Pump.fun New Tokens & Graduations Feed do?

**Pump.fun New Tokens & Graduations Feed** returns the newest pump.fun token launches and graduations, decoded directly from Solana on-chain data. Launch rows include the creator wallet, the dev's initial buy, bundled buyers in the create transaction and live bonding-curve progress. Graduation rows include the PumpSwap pool, liquidity and time to graduate. Pricing is pay per result: **$2.00 per 1,000 launches** and **$4.00 per 1,000 graduations**, with no subscription and no API key (bring your own Solana RPC for speed).

Built in Rust for speed, for quant and HFT research, signal generation and backtesting datasets. It is a batch data job (seconds to minutes per run), not a low-latency trading feed.

### What data you get

| Field group | Launch rows (`launch`) | Graduation rows (`graduation`) |
|---|---|---|
| Token | mint, name, symbol, metadata URI, Token-2022 flag, mayhem-mode flag | mint, name, symbol (Token-2022 metadata), token program |
| People | creator wallet, signer of the create | creator wallet (from the bonding curve) |
| Money | dev initial buy (tokens, % of supply, SOL, USD), bundled buyers and their % of supply | liquidity moved to the pool (SOL and USD), tokens to pool, migration fee |
| Market | bonding-curve progress %, complete flag, spot price, market cap (quote and USD) | current price and liquidity (DexScreener), launch time, minutes to graduate |
| Proof | slot, block time, signature, Solscan link | slot, block time, signature, PumpSwap pool, DexScreener and Solscan links |

Curves quoted in mints other than SOL (USDC, PUMP, xStock tokens) are decoded too: `quoteMint`, `isSolQuoted`, and USD values at the run's price.

### Use cases

- **Launch datasets for backtesting**: schedule every 5–15 minutes with `lookbackMinutes` to build a gap-free history of launches with dev-buy size and bundle share.
- **Signal research**: study how dev initial buy %, bundled buyers or quote asset relate to curve progress and graduation.
- **Graduation tracking**: get every curve that migrated to PumpSwap, with pool address and liquidity, to feed a watchlist.
- **Creator monitoring**: filter by `creatorWallets` to follow specific deployers.

### How to use it

1. Open the actor and keep the prefilled input (15 launches + 2 graduations). Click **Start**.
2. For volume, paste your own Solana RPC URL into **Solana RPC URL** (stored as an encrypted secret, never logged) and raise **Max RPC requests per second** to your plan's limit.
3. Use **Only the last N minutes** + an Apify schedule for a continuous feed. Use filters (min dev buy, SOL-quoted only, creator wallets) to narrow it down.
4. Download JSON/CSV/Excel, or read the dataset via the Apify API.

### Input example

```json
{
  "recordTypes": ["launches", "graduations"],
  "maxLaunches": 200,
  "maxGraduations": 20,
  "lookbackMinutes": 15,
  "includeCurveState": true,
  "minInitialBuySol": 0.5,
  "rpcUrl": "https://your-rpc.example.com/?api-key=..."
}
```

### Output example

```json
{
  "recordType": "launch",
  "mint": "E4XC9B3uadPd2mKkpxR2MfvGHU3AGfKhXXNxLiaVpump",
  "name": "YAGAMY",
  "symbol": "MONYH",
  "creator": "HVjNk6Hhe4CtqiCEoPPwm1LLSptBKNCmRM8noWsWSLWj",
  "isToken2022": true,
  "isSolQuoted": true,
  "createdAt": "2026-11-03T06:28:06Z",
  "initialBuySol": 1.477812826,
  "initialBuyPctOfSupply": 5.0375,
  "bundledBuyers": 0,
  "curveProgressPct": 0.0,
  "marketCapUsd": 1261.67,
  "signature": "5VcG8nd3Hsa3B5Uhuaj5NkHyanaDq51ruuN4H1zyH3kPGb7KJJSub5oJ97P7W5AyLJdAerQAyYrX9n5wEJi6HN54"
}
```

```json
{
  "recordType": "graduation",
  "mint": "YqWYcCmfGnwdw4denbrXWXHDNaQczLs3girPyyEpump",
  "symbol": "ROCAT",
  "pool": "5xa62vSVVRtEUvYdUBHZWQGMYvcm47YYRewH3kTob3ko",
  "liquiditySol": 150.175087369,
  "tokensToPool": 117093358.174485,
  "migrationFeeSol": 0.015000001,
  "graduatedAt": "2026-11-03T06:15:18Z"
}
```

Full prefill output: `samples/output_prefill.json` in the source.

### How much does it cost?

Pay per event, flat price for every plan:

| Event | Price | Per 1,000 |
|---|---|---|
| `launch` | $0.002 | $2.00 |
| `graduation` | $0.004 | $4.00 |

Worked example: a day of 15-minute runs with 200 launches and 5 graduations each (96 runs) is 19,200 launches and 480 graduations, so $38.40 + $1.92 = **$40.32**. Apify compute is billed separately and is small: about $0.03 per 1,000 records in our measured runs at 256 MB. The run's **max total charge** is respected: once the budget is reached, results stop and nothing more is charged.

### How fast is it? (measured)

- Decoder: **4,123 transactions/s on one core** (JSON parse + pump.fun event decode; `cargo test --release -- --ignored bench_decode`, AMD EPYC 9655P).
- End to end, the speed is set by your RPC's rate limit. On the public mainnet endpoint (about 3 requests/s), the measured run was 200 launches + 20 graduations in 529 s (0.42 records/s). The prefill (15 + 2) takes about 26 s. With your own RPC, raise **Max RPC requests per second** and the run scales accordingly.

### How it works and data sources

- **Launches**: the pump.fun mint authority `TSLvdd1pWpHVjahSpsvCXUbgwsL3JAcvokwaKt1eokM` signs every create/create_v2 and nothing else. Its signature history is the launch list. Each transaction's `CreateEvent` and `TradeEvent` (Anchor CPI events, per the official pump.fun IDL) is decoded.
- **Graduations**: migration transactions from `39azUYFWPz3VHgKCf3VChUwbpURdCHRxjWVowf5jUJjg`, decoded from `CompletePumpAmmMigrationEvent`.
- **Curve state**: bonding-curve accounts (`getMultipleAccounts`). Progress = share of the 793.1M sellable tokens bought.
- **Prices**: Jupiter Price API v3 (keyless), with GeckoTerminal as fallback. **Pools**: DexScreener public API (a few calls per run, within its documented limits).
- Unit discipline: 1 SOL = 1,000,000,000 lamports; pump.fun tokens have 6 decimals. Tests check both on recorded mainnet transactions.
- Read-only. The actor never signs, trades or touches private keys.

### How it compares

| Approach | Launch + dev-buy data | Graduations with pool | Effort | Terms |
|---|---|---|---|---|
| This actor | decoded CreateEvent/TradeEvent, bundled buyers, curve state | yes, from the migration event | one click or one API call | public blockchain data + public APIs |
| DIY with a Solana RPC | yes, once you write and maintain the decoders | yes | build and maintain IDL decoders, paging, retries | your RPC provider's terms |
| Scraping a launchpad website | whatever the page shows | sometimes | brittle; breaks with front-end changes | check the site's terms first |

### FAQ

#### Is there a pump.fun API for new tokens?

pump.fun has no official public API for launch history. This actor reads the same data from the Solana blockchain, which is public, and decodes the program's own events.

#### How do I detect pump.fun graduations (migrations to PumpSwap)?

Select **Graduations**. Each row is one curve that migrated, with pool address, SOL moved into the pool and the migration fee.

#### Can I track a specific pump.fun dev wallet?

Yes. Put wallets in **Creator wallets (filter)**. Filtering reads more transactions, so give it a larger time window.

#### What are "bundled buyers"?

Wallets other than the creator that bought inside the same transaction as the token creation. This is a common bundling pattern. The row includes their count and % of supply.

#### Does it support Token-2022 pump.fun tokens?

Yes. New pump.fun tokens (create_v2) are Token-2022 mints. `tokenProgram` and `isToken2022` tell you which program a token uses.

#### Do I need my own Solana RPC?

No. The public mainnet endpoint is used by default, but it is slow and rate-limited. For large or frequent runs, use your own RPC URL (Helius, Triton, QuickNode or your own node). It is stored as a secret input.

#### Is this real-time / suitable for sniping?

No. Apify runs are batch jobs with seconds-to-minutes latency. The data is meant for research, monitoring and backtesting, not for execution.

#### Is it legal?

The data comes from the public Solana blockchain via JSON-RPC, plus public price/pair APIs used within their documented limits. No website scraping, no logins.

### Integrations

Use the Apify API (`run-sync-get-dataset-items`), the Python and JavaScript API clients (`apify-client`), schedules, webhooks, and the Apify integrations for **n8n, Make, Zapier**, Google Sheets and Slack. AI agents can call it through the **Apify MCP server** (`actors: offgrid-labs/pumpfun-launch-graduation-feed`). The input and output schemas describe every field with units.

### Changelog

- 2026-11-03 · 0.1 · First release: launches (create/create_v2, dev initial buy, bundled buyers, curve state) and graduations (PumpSwap pool, liquidity, minutes to graduate); non-SOL quote curves; bring-your-own RPC.

### Related actors

| Actor | What it does |
|---|---|
| Solana DEX Trades & Order Flow | Swap tape, net flow, whales, first buyers and snipers for any token |
| Solana Token Holders & Rug Check | Holder concentration, dev wallet, fresh wallets, authorities, LP burn |

*Not financial advice. Data is provided as-is for research. Nothing here is a recommendation to buy or sell any token.*

***

```
// OFFGRID LABS ─────────────────────────────────────────────
// status: monitored 24/7 by a self-hosted agent swarm
// health checks: every 6h · auto-repair + rollback on failure
// sources: official public APIs and open data only
// support: open an issue — human-reviewed response within 24h
// ───────────────────────────────────────────────────────────
```

# Actor input Schema

## `recordTypes` (type: `array`):

Record types to save. Each record is one dataset row and one charge event. Example: \["launches", "graduations"].

## `maxLaunches` (type: `integer`):

Newest launches to return. pump.fun creates roughly one token per second, so 100 covers about the last 2 minutes.

## `maxGraduations` (type: `integer`):

Newest graduations (migrations to PumpSwap) to return. About 1% of launches graduate. Example: 20.

## `lookbackMinutes` (type: `integer`):

Stop at records older than this many minutes. 0 = no time limit (only the max counts apply). Schedule the actor every N minutes with the same value for a gap-free feed.

## `includeCurveState` (type: `boolean`):

Read each new token's bonding-curve account at the end of the run: progress %, complete flag, spot price and market cap.

## `minInitialBuySol` (type: `number`):

Only launches where the creator bought at least this much in the creation transaction (SOL, or the SOL value for tokens quoted in other mints). 0 = all.

## `solQuotedOnly` (type: `boolean`):

pump.fun also has curves quoted in other mints (e.g. USDC or PUMP). Enable to keep only SOL-quoted tokens.

## `creatorWallets` (type: `array`):

Only launches/graduations by these creator wallets. Leave empty for all. Filtering reads more transactions, so runs take longer. Example: GaJ7tPZqqBA8H9GMG5RCwnt866tYCTkcjwAWd55uEyJV.

## `rpcUrl` (type: `string`):

Your own Solana JSON-RPC endpoint (Helius, Triton, QuickNode, your node...). Stored encrypted and never logged. Empty = the public mainnet endpoint, which is rate-limited (about 3 requests/s), so large runs are slow.

## `maxRequestsPerSecond` (type: `integer`):

Throttle for your RPC plan. 0 = automatic (3/s on the public endpoint, 10/s on a custom URL). The public endpoint is always capped at 3.5/s.

## Actor input object example

```json
{
  "recordTypes": [
    "launches",
    "graduations"
  ],
  "maxLaunches": 15,
  "maxGraduations": 2,
  "lookbackMinutes": 0,
  "includeCurveState": true,
  "minInitialBuySol": 0,
  "solQuotedOnly": false,
  "maxRequestsPerSecond": 0
}
```

# Actor output Schema

## `results` (type: `string`):

All launches and graduations, every field (default dataset).

## `overview` (type: `string`):

Overview view: key fields only, one row per pump.fun token launch or graduation (migration to PumpSwap), decoded from Solana transactions.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "recordTypes": [
        "launches",
        "graduations"
    ],
    "maxLaunches": 15,
    "maxGraduations": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("offgrid-labs/pumpfun-launch-graduation-feed").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "recordTypes": [
        "launches",
        "graduations",
    ],
    "maxLaunches": 15,
    "maxGraduations": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("offgrid-labs/pumpfun-launch-graduation-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "recordTypes": [
    "launches",
    "graduations"
  ],
  "maxLaunches": 15,
  "maxGraduations": 2
}' |
apify call offgrid-labs/pumpfun-launch-graduation-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,offgrid-labs/pumpfun-launch-graduation-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ux1Zz9Vo8KVZOlNFT/builds/XQMtnt9EM4XsmGS0Q/openapi.json