# Pump.fun Graduated Tokens Dataset (`intenal_builds/pumpfun-graduated-tokens-dataset`) Actor

Historical + live pump.fun graduated tokens on Solana: launch time, graduation time, time-to-graduate, migration signature, PumpSwap pool and market-cap path (t+5m/1h/24h). One record per token.

- **URL**: https://apify.com/intenal_builds/pumpfun-graduated-tokens-dataset.md
- **Developed by:** [Jaydan Eaton](https://apify.com/intenal_builds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 tokens

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

## Pump.fun Graduated Tokens Dataset — Solana Memecoin Backtesting Data

Get a clean, **one-row-per-token dataset of pump.fun tokens that graduated** (completed the bonding curve and migrated to PumpSwap) on Solana. Every run combines:

- **Historical corpus** — **11,092 graduated pump.fun tokens** (graduations from 29 Jul 2026 to 25 Sep 2026), bundled with the actor, so results come back in seconds.
- **Live new graduations**: recently graduated coins pulled at run time from pump.fun's public API, with graduation time looked up on public Solana RPC, so the data stays current.

Use it for **memecoin backtesting**, graduation-rate research, time-to-graduate analysis, post-migration price-path studies, dashboards, and training data for Solana token analytics.

### What you get per token

| Field | Meaning |
|---|---|
| `mint`, `name`, `symbol`, `creator` | Token identity and public creator wallet |
| `launchTime` | Creation time reported by pump.fun (UTC) |
| `graduationTime` | Block time of the migration transaction (UTC) |
| `timeToGraduateSec` | Seconds from launch to graduation (0 means created and migrated in the same second, i.e. a bundled launch) |
| `migrationSignature` | Solana transaction signature you can verify on any explorer |
| `pumpSwapPool`, `quoteMint`, `program` | Post-graduation pool and quote asset |
| `mcapAtGraduationUsd` | USD market cap at graduation |
| `mcapT5mUsd`, `mcapT1hUsd`, `mcapT24hUsd` | USD market cap 5 min, 1 h and 24 h after graduation |
| `maxMcapFirst1hUsd`, `maxMcapFirst24hUsd` | Peak market cap in that window (only filled when candle coverage is complete) |
| `athMarketCapUsd`, `athTime` | All-time-high market cap reported by pump.fun |
| `twitter`, `telegram`, `website`, `nsfw` | Public token metadata links and flags |
| `snapshotMarketCapUsd`, `lastTradeTime`, `candleCount`, `dataSource` | Collection context |

**No invented numbers.** Market caps come from 1-minute (or 5-minute) OHLCV candle closes × the 1B pump.fun supply. If the source has no candle near a checkpoint, the field is `null`; we never estimate it. In the historical corpus, coverage is: t+5m on 5,866 tokens, t+1h on 3,384, t+24h on 1,364. Live tokens usually have no t+24h yet.

### Filters (input)

- **Data source**: live + historical (default), historical only, or live only
- **Graduation date range**: `startDate` / `endDate` (UTC)
- **Mint addresses**: look up specific tokens
- **Min ATH market cap (USD)** and **min market cap at graduation (USD)**
- **Only tokens with a price path**, **include NSFW**, **oldest first**
- **Max live tokens**, **max results**, and an optional Solana RPC URL of your own

Example input:

```json
{ "mode": "historical", "startDate": "2026-09-01", "endDate": "2026-09-25", "minAthMarketCapUsd": 100000, "onlyWithPricePath": true, "maxResults": 500 }
```

### Pricing

Pay per event: you're charged per token record returned (`token` event). Use `maxResults` to cap what you spend.

### Data sources and scope

All data is public: pump.fun's public coin listing and candle endpoints, and Solana mainnet transactions. The actor holds no wallet keys and makes no trades. Live graduation time is the block time of the newest successful bonding-curve transaction (the migration), labeled in `graduationTimeMethod`. pump.fun's public listing only goes back about a day, so for older tokens use the historical corpus.

### FAQ

**Is this the full pump.fun history?** No. It covers the graduations in the bundled window plus whatever live graduations the public API lists at run time.

**Why are some price fields null?** The source had no candle data near that checkpoint. We leave the field empty rather than guess.

**Can I export to CSV/Excel?** Yes. Apify datasets export to CSV, JSON, Excel, and more, and you can also pull them over the API.

### Disclaimer

This dataset is for research and educational purposes only. **It is not financial advice.** Memecoins are extremely volatile and many go to zero. Past price paths say nothing about future results. Not affiliated with pump.fun.

### More from Intenal_Builds

- [Crypto Launch Radar](https://apify.com/intenal_builds/crypto-launch-radar) - new tokens and pairs from DEX Screener and GeckoTerminal
- [Memecoin Alpha Caller Leaderboard](https://apify.com/intenal_builds/memecoin-caller-track-record) - pump.fun KOL caller hit rates and consistency
- [AI Trend Radar](https://apify.com/intenal_builds/ai-trend-radar) - trending Hugging Face, GitHub and arXiv AI projects

# Actor input Schema

## `mode` (type: `string`):

'historical' serves the bundled corpus (graduations from late Jul to late Sep 2026). 'live' fetches recently graduated coins from pump.fun's public API and resolves graduation time via public Solana RPC. 'both' returns live first, then historical.

## `startDate` (type: `string`):

YYYY-MM-DD or ISO timestamp (UTC). Filters on graduation time. Empty = no lower bound.

## `endDate` (type: `string`):

YYYY-MM-DD (inclusive, UTC) or ISO timestamp. Empty = no upper bound.

## `mints` (type: `array`):

Return only these token mint addresses. Empty = all tokens.

## `minAthMarketCapUsd` (type: `integer`):

Keep tokens whose pump.fun-reported ATH market cap is at least this value. 0 = no filter.

## `minMcapAtGraduationUsd` (type: `integer`):

Keep tokens whose candle-derived market cap at graduation is at least this. Tokens without candle coverage at graduation are excluded when > 0.

## `onlyWithPricePath` (type: `boolean`):

Keep only tokens that have at least a t+5m market-cap value derived from candles.

## `includeNsfw` (type: `boolean`):

Include tokens pump.fun flags as NSFW.

## `oldestFirst` (type: `boolean`):

Sort historical records by graduation time ascending instead of newest first.

## `liveMaxTokens` (type: `integer`):

Maximum recently graduated tokens to fetch live (each needs ~2 public API calls; ~1.5 s per token).

## `solanaRpcUrl` (type: `string`):

Optional own RPC endpoint for graduation-time lookups. Defaults to the free public mainnet-beta endpoint.

## `maxResults` (type: `integer`):

Maximum total tokens to output (each output token is one billable 'token' event).

## Actor input object example

```json
{
  "mode": "both",
  "minAthMarketCapUsd": 0,
  "minMcapAtGraduationUsd": 0,
  "onlyWithPricePath": false,
  "includeNsfw": true,
  "oldestFirst": false,
  "liveMaxTokens": 50,
  "maxResults": 1000
}
```

# Actor output Schema

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

One item per graduated pump.fun token.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("intenal_builds/pumpfun-graduated-tokens-dataset").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("intenal_builds/pumpfun-graduated-tokens-dataset").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 '{}' |
apify call intenal_builds/pumpfun-graduated-tokens-dataset --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,intenal_builds/pumpfun-graduated-tokens-dataset"
        }
    }
}
```

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/BlZcLP7UPnQjoQpiJ/builds/fh131kC8Gvt6QbKsY/openapi.json