# Pump.fun Scraper - New Tokens Monitor, New Coins & Graduations (`neverempty/pump-fun-new-tokens-monitor`) Actor

For Solana memecoin bots and on-chain analysts: every new pump.fun token with mint, name, symbol, creator, market cap, bonding curve progress, graduation to PumpSwap or Raydium and social links. About 30 launched a minute on 2026-09-24; watch mode returns only new or graduated ones. No API key.

- **URL**: https://apify.com/neverempty/pump-fun-new-tokens-monitor.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Automation, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 token returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 New Tokens Monitor - New Coins & Graduations

For bot builders, on-chain analysts and dashboards: the newest tokens on pump.fun as they are created, one row per token with its mint address, name, symbol, creator wallet, market cap in USD and SOL, bonding curve progress, whether it graduated and to which pool (PumpSwap or Raydium), age in minutes and the X (Twitter), Telegram and website links its creator added. Turn on watch mode, run it on a schedule, and each run returns only the tokens created since your last run and the tokens that graduated since your last run, instead of the same list again.

Unofficial. Reads pump.fun's public front-end API (`frontend-api-v3.pump.fun`) with no login, no API key and no browser. Export as JSON, CSV or Excel, or read the dataset from your own code.

**Information only. This Actor returns public market data as pump.fun shows it. It is not investment advice, does not rate tokens and does not place orders.**

### Why this Actor

- **Watch mode: only what is new.** With `onlyNew` on, the Actor remembers what it has seen and later runs return two kinds of rows: `new-token` (new on pump.fun's list since the last check) and `graduated` (bonding curve completed since the last check). A run that finds nothing new returns one free row that says so. Tokens are told apart by their creation time: a token the Actor never saw that is older than the range it read last time (for example one that pump.fun had hidden and shows again) is not sold to you as new.
- **Bonding curve progress and graduation on every row.** `bondingCurveProgressPct` is computed from the tokens left on the curve (pump.fun's coin page shows the same figure rounded up to a whole percent; compared on 8 coin pages on 2026-09-25, reading the API right after each page). `isGraduated`, `migratedTo` (PumpSwap or Raydium) and `poolAddress` say where a graduated token now trades.
- **Filters that run before you pay.** `minMarketCapUsd`, `maxMarketCapUsd`, `minBondingCurveProgress` and `onlyWithSocialLinks` are applied before rows are returned, so tokens you filter out are not charged.
- **Honest empty results.** A list that could not be read, a check page, nothing new, no token meeting the filters and a run that hit its maximum charge each come back as a free row that says so. Missing values are `null`, never 0 or an empty string.

Measured on 2026-09-24 between 21:34 and 21:44 UTC: pump.fun created 300 tokens in about 10 minutes (about 30 a minute), and the newest 100 graduated tokens had been created over the previous 2 hours.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `lists` | select | (none = both) | `new-tokens` (newest created) and/or `graduated` (bonding curve completed, newest created first). |
| `onlyNew` | boolean | false | Watch mode: return only tokens created or graduated since the last run of this watch. |
| `maxResults` | integer | 25 (watch mode: every new token read, up to 300) | At most this many token rows per list and run. |
| `minMarketCapUsd` | number | (none) | Only tokens with at least this market cap in USD when the run reads them. |
| `maxMarketCapUsd` | number | (none) | Only tokens with at most this market cap in USD. |
| `minBondingCurveProgress` | number | (none) | Only tokens whose bonding curve is at least this far (0 to 100; graduated = 100). |
| `onlyWithSocialLinks` | boolean | false | Only tokens with an X, Telegram or website link. |
| `includeNsfw` | boolean | false | Include tokens pump.fun marks NSFW (hidden by default on pump.fun). |
| `watchName` | string | (none) | A name for this watch; use one per schedule. |
| `resetMonitoringState` | boolean | false | Start this watch over (the next rows are first-check again). Turn it off after one run. |

Examples:

```json
{ "lists": ["new-tokens"], "onlyNew": true, "watchName": "new-every-minute" }
```

```json
{ "lists": ["graduated"], "onlyNew": true, "minMarketCapUsd": 50000, "watchName": "graduations" }
```

```json
{ "lists": ["new-tokens"], "onlyWithSocialLinks": true, "maxResults": 50 }
```

### Output

One row per token. Example (a watch-mode run on 2026-09-24 at 21:59 UTC, 6 seconds after the token was created):

```json
{
  "status": "ok",
  "changeType": "new-token",
  "list": "new-tokens",
  "mint": "AtJYtYhQ6qP9LjArEaNFdbymSr6y1tCrid9iD15ppump",
  "name": "The American Woodcock",
  "symbol": "WOODCOCK",
  "marketCapUsd": 4633.44,
  "marketCapSol": 39.66,
  "bondingCurveProgressPct": 21.69,
  "quoteInBondingCurve": 5.73,
  "quoteToken": "SOL",
  "isGraduated": false,
  "migratedTo": null,
  "poolAddress": null,
  "createdAt": "2026-09-24T21:59:27.000Z",
  "ageMinutes": 0.11,
  "creator": "8sZCezS3SpzL4GCD9FNkYswUaJm3YkScusKSuUetBz4F",
  "creatorName": "wagmiotterstray",
  "twitter": "https://x.com/mrwhobob_/status/2103242621489475775",
  "telegram": null,
  "website": "https://www.tiktok.com/@mpregwarrior3/video/7687960204545182989",
  "pumpFunUrl": "https://pump.fun/coin/AtJYtYhQ6qP9LjArEaNFdbymSr6y1tCrid9iD15ppump"
}
```

| Column | Meaning |
|---|---|
| `changeType` | Watch mode only: `first-check` (first run of a watch, the starting point), `new-token` (new on the list since the last check) or `graduated` (graduated since the last check). `null` with watch mode off. |
| `list` | The list the row came from: `new-tokens` or `graduated`. |
| `marketCapUsd`, `marketCapSol` | Market cap as pump.fun reports it. `marketCapSol` only for tokens paired with SOL (a few are paired with USDC or another token; `quoteToken` says which). |
| `bondingCurveProgressPct`, `quoteInBondingCurve` | How far the bonding curve is (100 = graduated) and how much SOL (or other quote token) is in it. `quoteInBondingCurve` is `null` after graduation. |
| `isGraduated`, `migratedTo`, `poolAddress` | Whether the curve completed, the pool it moved to (`PumpSwap`, older tokens `Raydium`) and that pool's address. |
| `createdAt`, `ageMinutes`, `lastTradeAt` | When the token was created, its age when the run read it, and its last trade as pump.fun reports it. |
| `athMarketCapUsd`, `athMarketCapAt` | Highest market cap pump.fun recorded for the token and when. |
| `creator`, `creatorName` | The creator's wallet and pump.fun profile name. |
| `twitter`, `telegram`, `website`, `description`, `imageUrl`, `metadataUrl` | What the creator entered, as pump.fun shows it (links only when they are web addresses). |
| `replyCount`, `isLive`, `isNsfw`, `bondingCurveAddress`, `pumpFunUrl` | Comment count, whether a livestream is on, NSFW flag, the bonding curve account and the token's pump.fun page. |

Rows whose `status` is not `ok` are free and explain themselves in `note`: `no-new-tokens`, `none-matching`, `no-tokens`, `more-not-returned`, `more-new-than-readable`, `blocked`, `unreadable`, `incomplete`, `budget-reached`, `bad-input`.

### Pricing

- A **run start fee** per run that read a list (in watch mode also when nothing was new: it pays for the check). Not charged when pump.fun could not be read.
- A price **per token row** returned. Free rows cost nothing.
- A run whose maximum total charge has no room for the start fee and one token row requests nothing and is charged nothing.

The current prices are on the Pricing tab.

### Watch mode

Turn on `onlyNew` and run the Actor on a schedule (Apify Schedules, or the API from your bot). The first run returns the newest page (50 tokens) of each list as `first-check`. Later runs read back to where the last run stopped (up to 6 pages, 300 tokens, per list) and return:

- `new-token`: a token it had not seen, created after the oldest of the 50 newest tokens it read last time. That is normally a token created since the last run; a token pump.fun added to its list a few seconds late also counts (in a run on 2026-09-24, 1 of 14 new tokens had been created 12 seconds before the previous run's newest token).
- `graduated`: a graduated token it had not seen, created after the oldest of the 100 newest graduated tokens it read last time. A token created long before it graduates (older than those 100) is not seen by the graduation watch.

What each watch remembers is kept per `watchName`, list and filters in a named key-value store. Tokens left out by `maxResults` or by the run's maximum charge are returned by the next run if they are still among the tokens it reads. Filters are checked when a token is first seen: a new token below `minMarketCapUsd` then is not returned later by the new-tokens watch if it grows.

How often: about 30 tokens a minute were created on 2026-09-24, so a run reads the new ones since the last run in up to 6 pages (about 10 minutes of tokens). Run the new-tokens watch every 1 to 5 minutes; if more appeared than a run can read, a free `more-new-than-readable` row says so. pump.fun's list itself reaches back only about the last 1,100 tokens. Do not run two schedules with the same `watchName`, lists and filters at the same time (Apify's key-value store has no atomic update).

### Notes and limits

- pump.fun's API answers at most 60 requests a minute from one IP address. If it answers HTTP 429 (or another refusal) the Actor asks again, then once more through an Apify residential IP address. It never solves or bypasses a check page; if one appears, the run stops with a free `blocked` row and charges nothing.
- The data is what pump.fun's public API returns at the moment of the run; market caps change within seconds on new tokens.
- This Actor is not affiliated with or endorsed by pump.fun. Information only, not investment advice.

### Support

Questions or a problem? Open an issue on the Issues tab with the run ID.

# Actor input Schema

## `lists` (type: `array`):

new-tokens = the newest tokens created on pump.fun, newest first. graduated = tokens whose bonding curve completed and that moved to PumpSwap (older ones to Raydium), newest created first. If you choose none, both are read.

## `onlyNew` (type: `boolean`):

Off = the newest tokens of each list come back, up to maxResults per list. On = the Actor remembers what it has seen (per watchName, list and filters) and later runs return only tokens created since the last check (new-token) and tokens that graduated since the last check (graduated). The first run returns the newest page of each list once as a starting point (first-check). A run in watch mode charges the run start fee when it could read and compare a list, also when nothing is new. Run it on a schedule, for example every 1 to 5 minutes.

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

At most this many token rows per list and run. Empty = 25 with watch mode off, and every new token the run reads (up to 300 per list) with watch mode on. In watch mode, new tokens left out by this limit are returned by the next run if they are still among the tokens it reads.

## `minMarketCapUsd` (type: `number`):

Return only tokens whose market cap in USD, as pump.fun shows it when the run reads it, is at least this. In watch mode a token is judged once, when it is first seen: a token below the minimum then is not returned later by the new-tokens watch if it grows (the graduated watch still returns it when it graduates and meets the filters).

## `maxMarketCapUsd` (type: `number`):

Return only tokens whose market cap in USD is at most this.

## `minBondingCurveProgress` (type: `number`):

Return only tokens whose bonding curve is at least this far (0 to 100). Graduated tokens count as 100.

## `onlyWithSocialLinks` (type: `boolean`):

Return only tokens whose creator added at least one of X (Twitter), Telegram or a website.

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

pump.fun hides tokens marked NSFW by default. On = include them.

## `watchName` (type: `string`):

Optional name for this watch (letters, digits, dot, dash, underscore). Use a different name for each schedule so two schedules do not share what they remember. The lists and filters are part of the watch as well.

## `resetMonitoringState` (type: `boolean`):

On = this run starts the watch over and returns the newest page of each list again as first-check. Turn it off again after one run: left on in a schedule, every run is a first check.

## Actor input object example

```json
{
  "lists": [
    "new-tokens",
    "graduated"
  ],
  "onlyNew": false,
  "onlyWithSocialLinks": false,
  "includeNsfw": false,
  "resetMonitoringState": false
}
```

# Actor output Schema

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

One row per pump.fun token: mint, name, symbol, market cap in USD and SOL, bonding curve progress, whether it graduated and to which pool (PumpSwap or Raydium), creation time and age in minutes, creator wallet, X, Telegram and website links, image and pump.fun link. Watch mode marks rows first-check, new-token or graduated. A list that could not be read, nothing new, no token meeting the filters or a run that hit its maximum charge comes back as a free row that says why.

# 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 = {
    "lists": [
        "new-tokens",
        "graduated"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/pump-fun-new-tokens-monitor").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 = { "lists": [
        "new-tokens",
        "graduated",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/pump-fun-new-tokens-monitor").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 '{
  "lists": [
    "new-tokens",
    "graduated"
  ]
}' |
apify call neverempty/pump-fun-new-tokens-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/pump-fun-new-tokens-monitor"
        }
    }
}
```

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/3l9sdrsTuEfyzgvgD/builds/aZFaaeyCjeE6Qg6TW/openapi.json