# Pump.fun Live Token Screener - New Launches, Snipers, Dev Sells (`centorprat/pumpfun-live-launch-screener`) Actor

Listen to pump.fun live and catch new launches matching your screen: buyers, buy ratio, volume, holders, top-10 %, dev sold %, snipers, bundles, curve progress. Matches arrive in real time and are followed to the end of the run. Max tier: up to 2 h and holder traces.

- **URL**: https://apify.com/centorprat/pumpfun-live-launch-screener.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.50 / 1,000 matched tokens

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 Live Token Screener — New Launches, Snipers, Dev Sells

Watch **pump.fun live** and catch the new tokens that match **your** screen. While the run listens, every pump.fun launch and trade on Solana is read straight from the chain. Every 20 seconds each token gets **80+ fields**:

- buyers, buy ratio, volume and price change in 5m / 15m / 30m / 1h / 6h windows;
- holders and top-10 %;
- dev buy and dev sold %;
- snipers and bundles;
- curve progress and drawdown.

Your filters then run on those fields. A matching token is **pushed to the dataset at once** (and to your webhook) and **followed until the run ends**, so you also see what happened after it matched.

> **Signals for research, not financial advice.** New tokens can lose all value in seconds.

### How it works

1. Pick a **preset** (or `every-launch`) and add your own **filters**, e.g. `{"marketCapUsd": {"max": 60000}, "buyers.m5": {"min": 40}}`.
2. Choose how long to **listen** (1–30 minutes; up to 120 on the max tier).
3. Matches arrive as `status: "match"` rows the moment they qualify.
4. At the end, one `status: "result"` row per match gives the **peak, low and last market cap vs the match** (and the holder trace on the max tier).

### Presets

| preset | what it catches |
|---|---|
| `fresh-momentum` | 3–60 min old, 25+ unique buyers in 5 min, 60%+ buys, dev sold ≤ 50%, top-10 ≤ 40%, bundles ≤ 15% |
| `clean-launch` | snipers ≤ 10%, bundles ≤ 5%, dev holds ≤ 5% and hasn't sold, top-10 ≤ 30%, 40+ holders |
| `near-graduation` | bonding curve 70–99.5% with buy-heavy flow |
| `graduated` | completed the curve while you listened |
| `volume-spike` | 5-min volume ≥ 2× its 1-hour pace, price +5% in 5 min, $3k+ volume |
| `dev-dump` | dev sold 80%+ and price 40%+ off its peak (an avoid / exit list) |
| `every-launch` | every new token with a trade (bring your own filters) |

### Two tiers: standard and max

| | standard | max |
|---|---|---|
| Listening time | up to 30 min | up to 120 min |
| Presets + your filters, real-time webhook, follow-up | ✅ | ✅ |
| **Holder trace** of each match (early buyers' funding wallets, bundles, dev-linked wallets, coordination risk %) | — | ✅ (up to 20 matches) |
| Price | per matched token + per listening minute | max price per matched token + per listening minute |

### Filter conditions

`{"field": {"min": x, "max": y}}`, `{"field": true}`, `{"field": {"in": [...]}}`, `{"field": {"exists": true}}`. Your filters are added on top of the preset (same field = yours wins).

#### Fields

| field | meaning |
|---|---|
| `ageMinutes` | minutes since the token / pool was created |
| `bundleSupplyPct` | % of supply bought in the creation slot |
| `bundlers` | wallets that bought in the creation slot itself (bundled launch) |
| `curveProgressPct` | pump.fun bonding curve progress 0-100 (100 = graduates) |
| `devFirstSellMinutesAfterLaunch` | minutes after launch the creator first sold |
| `devHoldsPct` | % of supply the creator wallet still holds |
| `devInitialBuySol` | SOL the creator bought at launch |
| `devSold` | the creator wallet has sold any |
| `devSoldPct` | % of the creator's bought tokens sold |
| `drawdownFromPeakPct` | % below the peak market cap now |
| `graduated` | pump.fun token that completed its bonding curve (moved to a DEX) |
| `holders` | wallets holding a positive balance (pump.fun, from trades) |
| `marketCapSol` | market cap in SOL (pump.fun) |
| `marketCapUsd` | market cap in USD now |
| `minutesSincePeak` | minutes since the peak |
| `name` | token name |
| `peakMarketCapUsd` | highest market cap seen since launch |
| `priceConfidence` | high | low (low = curve priced in an illiquid token: market cap / volume are rough). Screens return only high unless you filter on this field |
| `quote` | what the pump.fun curve is priced in: SOL, PUMP, or another token's mint |
| `sniperHoldPct` | % of supply snipers still hold |
| `sniperSupplyPct` | % of supply snipers bought at launch |
| `snipers` | wallets (not the dev) that bought within 2 slots of creation |
| `symbol` | token symbol |
| `token` | token mint / contract address |
| `top10HolderPct` | % of supply held by the 10 largest holders (pump.fun, curve excluded) |
| `top1HolderPct` | % of supply held by the largest holder (pump.fun, curve excluded) |
| `tradesTotal` | trades since launch (pump.fun) |
| `volumeAcceleration` | 5-minute volume x 12 / 1-hour volume (>1 = speeding up) |

#### Window fields (`.m5`, `.m15`, `.m30`, `.h1`, `.h6`)

| field | meaning |
|---|---|
| `buyRatio` | buys / trades (0-1) |
| `buyVolumeUsd` | USD bought |
| `buyers` | unique buying wallets |
| `buys` | buy trades |
| `netBuyers` | buyers minus sellers |
| `priceChangePct` | % price change |
| `sellVolumeUsd` | USD sold |
| `sellers` | unique selling wallets |
| `sells` | sell trades |
| `trades` | trades |
| `volumeUsd` | USD volume |

### Input example

```json
{ "listenMinutes": 15, "preset": "fresh-momentum", "filters": {"marketCapUsd": {"max": 60000}}, "maxMatches": 20,
  "webhookUrl": "https://example.com/hook" }
```

### Output

```json
{ "status": "match", "token": "...pump", "symbol": "XYZ", "matchedAt": "2026-10-24T03:41:20Z", "ageMinutes": 7.5,
  "marketCapUsd": 21800, "buyers.m5": 61, "buyRatio.m5": 0.71, "holders": 88, "top10HolderPct": 24.1, "devSoldPct": 0,
  "snipers": 3, "sniperSupplyPct": 4.2, "bundleSupplyPct": 0, "url": "https://pump.fun/coin/...pump" }
{ "status": "result", "token": "...pump", "peakSinceMatchPct": 142.0, "lowSinceMatchPct": -18.5, "lastVsMatchPct": 64.3,
  "holderTrace": {"verdict": "mostly independent buyers", "coordinationRiskPct": 6} }
```

### Why not just ask an AI agent?

An agent can't sit on the Solana firehose for you. This decodes every pump.fun launch and trade as it happens and keeps live holder, sniper and bundle books for each token. Your screen runs on them every 20 seconds, so you get the token while it's still early, plus what happened after.

### Notes

- Data comes straight from the chain (public Solana RPC websocket, two redundant connections). Curves priced in another token (e.g. PUMP) are converted at live prices. Where that price is too thin to trust, the token is left out unless you filter on `priceConfidence`.
- `onlyNewLaunches` (default on) keeps only tokens created while you listen, so their launch data is complete.

# Actor input Schema

## `listenMinutes` (type: `integer`):

How long the run watches pump.fun live. Standard: up to 30. Max tier: up to 120. Listening is charged per minute.

## `preset` (type: `string`):

Starting screen. fresh-momentum: 3-60 min old, 25+ buyers in 5 min, buy-heavy, dev not dumping. clean-launch: few snipers / bundles, dev holds little. near-graduation: curve 70-99%. graduated: completed the curve while listening. volume-spike: 5-min volume speeding up with price rising. dev-dump: dev sold most of its bag (avoid list). every-launch: everything (use filters).

## `filters` (type: `object`):

Add or override conditions: {"field": {"min": x, "max": y}} or {"field": true/false}. Fields include ageMinutes, marketCapUsd, buyers.m5, buyRatio.m5, volumeUsd.m15, priceChangePct.m5, holders, top10HolderPct, devHoldsPct, devSoldPct, devInitialBuySol, snipers, sniperSupplyPct, bundleSupplyPct, curveProgressPct, drawdownFromPeakPct (windows m5, m15, m30, h1, h6). Full list in the README.

## `onlyNewLaunches` (type: `boolean`):

On (default): only tokens created during the run, so launch data (dev buy, snipers, bundles) is complete. Off: also active older tokens, with stats counted from the run start.

## `maxMatches` (type: `integer`):

Stop collecting after this many matching tokens (each match is charged).

## `tier` (type: `string`):

standard: up to 30 minutes. max: up to 120 minutes, and each match (up to 'Trace top matches') gets a holder trace: early buyers' funding wallets, bundles, dev-linked wallets, coordination risk %. Max matches are charged at the max price.

## `traceTopMatches` (type: `integer`):

Max tier only: how many of the first matches get a holder trace (0-20).

## `webhookUrl` (type: `string`):

Matches are POSTed here the moment they are found, and a final summary when the run ends.

## Actor input object example

```json
{
  "listenMinutes": 2,
  "preset": "every-launch",
  "filters": {
    "marketCapUsd": {
      "max": 60000
    },
    "buyers.m5": {
      "min": 3
    },
    "devSoldPct": {
      "max": 50
    }
  },
  "onlyNewLaunches": true,
  "maxMatches": 10,
  "tier": "standard",
  "traceTopMatches": 5
}
```

# Actor output Schema

## `matches` (type: `string`):

status=match rows: each token at the moment it matched (80+ fields). status=result rows at the end: peak / low / last market cap vs the match, and the holder trace on the max tier.

# 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 = {
    "listenMinutes": 2,
    "preset": "every-launch",
    "filters": {
        "marketCapUsd": {
            "max": 60000
        },
        "buyers.m5": {
            "min": 3
        },
        "devSoldPct": {
            "max": 50
        }
    },
    "maxMatches": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/pumpfun-live-launch-screener").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 = {
    "listenMinutes": 2,
    "preset": "every-launch",
    "filters": {
        "marketCapUsd": { "max": 60000 },
        "buyers.m5": { "min": 3 },
        "devSoldPct": { "max": 50 },
    },
    "maxMatches": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/pumpfun-live-launch-screener").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 '{
  "listenMinutes": 2,
  "preset": "every-launch",
  "filters": {
    "marketCapUsd": {
      "max": 60000
    },
    "buyers.m5": {
      "min": 3
    },
    "devSoldPct": {
      "max": 50
    }
  },
  "maxMatches": 10
}' |
apify call centorprat/pumpfun-live-launch-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/pumpfun-live-launch-screener"
        }
    }
}
```

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/CRtndZFB7hAGFqfMA/builds/ay8OJD5OUpVLtgBCG/openapi.json