# Pump.fun Token Scraper - New Launches, Bonding Curve & Holders (`scrapersdelight/pumpfun-token-scraper`) Actor

Scrape pump.fun tokens: new launches, about-to-graduate, graduated, movers, live and keyword search, or look up mints and creator wallets. Each row: mint, creator, market cap, price, ATH, bonding curve, socials, holders, top-10/dev/sniper share, 24h volume. Monitor mode for new tokens. No login.

- **URL**: https://apify.com/scrapersdelight/pumpfun-token-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.45 / 1,000 token rows

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 Token Scraper do?

**Pump.fun Token Scraper** pulls Solana memecoin data from [pump.fun](https://pump.fun) into clean rows: one row per token with its mint address, name, ticker, creator wallet, market cap, price, all-time high, bonding-curve progress, graduation status, socials and age. Switch on extra data and the same row also carries holder distribution, 5-minute to 24-hour market activity, the top holders, recent trades, the creator's launch history and trader callouts. Built for memecoin traders, trading bots, on-chain analysts and AI agents that need pump.fun data without running their own indexer.

Also searched as: pump.fun scraper · pump.fun API · pumpfun token tracker · Solana memecoin launch tracker · pump.fun new tokens monitor.

- **Every pump.fun feed:** new launches, about to graduate, graduated, movers, live streams, Mayhem mode, charity, plus deep listings (top market cap, recently traded, most replies, top ATH) up to 1,070 tokens each.
- **Search, look up and follow wallets:** keyword search (last 7 days or all time), mint-address or URL lookup, and every token a creator wallet launched.
- **Risk data on the row:** holders, top-10 / creator / sniper / bundler share of supply, lifetime fees, and a creator rug-risk score built from the wallet's own launch history.
- **Market activity:** volume, transactions and price change for 5 m, 1 h, 6 h and 24 h, plus 24 h buys, sells, buyers and sellers.
- **Monitor mode:** remembers what it delivered and returns only new tokens on the next scheduled run, or a token again once when it graduates.
- **No login, no API key, no wallet.**
- **Export anywhere:** JSON, CSV, Excel; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Telegram alerts, the Apify API and MCP.

### What data can you get from pump.fun?

<table>
<tr><td>🪙 Mint address (<code>mint</code>)</td><td>🏷️ Name + ticker</td><td>👤 Creator wallet</td></tr>
<tr><td>💰 Market cap in USD and SOL</td><td>💲 Price in USD and SOL</td><td>🚀 All-time-high market cap + date</td></tr>
<tr><td>📉 Drop from ATH (<code>ath_drawdown_pct</code>)</td><td>📈 Bonding-curve progress %</td><td>🎓 Graduated + pool address</td></tr>
<tr><td>🐦 X, Telegram, website links</td><td>⏱️ Created time + age in minutes</td><td>💧 Liquidity in USD</td></tr>
<tr><td>👥 Holders</td><td>🐋 Top-10 / creator / sniper / bundler share</td><td>🔥 Lifetime fees (SOL + USD)</td></tr>
<tr><td>📊 Volume + txns 5m / 1h / 6h / 24h</td><td>🔁 24h buys, sells, buyers, sellers</td><td>📐 Price change 5m / 1h / 6h / 24h</td></tr>
<tr><td>🏆 Top holders list</td><td>🧾 Recent trades</td><td>🧑‍💻 Creator launches, graduation rate, rug-risk score</td></tr>
<tr><td>📣 Trader callouts (thesis, entry, multiple)</td><td>🔴 Live-stream flag + title</td><td>🔗 pump.fun + Solscan links</td></tr>
</table>

On a 100-token run of the new-launches feed (2026-10-14): market cap, price, creator, liquidity and 24h market activity were filled on 99-100% of rows, holders and top-10 share on 97%, an X link on 57%, a website on 33%, and bonding-curve progress on 74% (the rest were Mayhem-mode tokens, whose curve is not the standard one).

### How to scrape pump.fun with Pump.fun Token Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) — the free plan's monthly credit covers thousands of tokens.
2. Open [Pump.fun Token Scraper](https://apify.com/scrapersdelight/pumpfun-token-scraper) and click **Try for free**.
3. Pick a **Mode** (a feed, a search, mint lookup, creator wallets or callouts) and set **Max tokens**.
4. Add filters (market cap, age, curve progress, holders, socials) and switch on the **Extra data** you want.
5. Click **Start**. Rows land in the dataset page by page.
6. **Export** as JSON, CSV or Excel from the Storage tab — or schedule it with monitor mode for a live new-launch feed.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to scrape** | | |
| `mode` | Select | `feed` (default), `search`, `tokens`, `creators`, `callouts`. |
| `feed` | Select | Feed mode: `new` (default), `graduating`, `graduated`, `movers`, `live`, `mayhem`, `charity`, `topMarketCap`, `recentlyTraded`, `mostReplies`, `recentlyReplied`, `topAth`, `newest`. |
| `searchTerms` | List | Search mode, e.g. `["pepe", "ai agent"]`. Each term gets its own `maxResults`. |
| `searchAllTime` | Boolean | Off = pump.fun's 7-day search; on = every token ever launched. Default `false`. |
| `tokens` | List | Tokens mode: mint addresses or `https://pump.fun/coin/<mint>` URLs. |
| `creatorWallets` | List | Creators mode: wallet addresses; each gets its own `maxResults` (up to 1,070). |
| **🎯 Filters** | | |
| `graduationState` | Select | `any` (default), `active` (still on the curve), `graduated`. |
| `includeNsfw` | Boolean | Include NSFW-flagged tokens. Default `false`. |
| `includeEvmTokens` | Boolean | Include non-Solana tokens that pump.fun lists on movers/search. Default `false`. |
| `minMarketCapUsd` / `maxMarketCapUsd` | Number | Market cap range in USD. |
| `minAgeMinutes` / `maxAgeMinutes` | Number | Token age range, e.g. `maxAgeMinutes: 30`. |
| **✂️ Refine results** | | |
| `minBondingCurveProgress` / `maxBondingCurveProgress` | Number | 0-100. Graduated tokens count as 100. |
| `minAthDrawdownPercent` | Number | Keep tokens at least this far below their ATH. |
| `minHolders`, `maxTop10HoldersPercent`, `maxDevHoldingsPercent` | Number | Holder-distribution screens. |
| `minVolume24hUsd` | Number | Minimum 24h volume. |
| `requiredSocials` / `requireAnySocial` | List / Boolean | Require X, Telegram and/or website. |
| `includeKeywords` / `excludeKeywords` | List | Name or ticker contains / does not contain. |
| `excludeCreators` | List | Blocked creator wallets. |
| `programs` | List | Launch programs, e.g. `pump`, `meteora_dbc`. |
| `fieldFilters` | JSON | Min/max on any numeric output field. |
| **➕ Extra data** (no extra charge) | | |
| `includeHolderStats` | Boolean | Holders + top-10/creator/sniper/bundler share + lifetime fees. Default `true`. |
| `includeMarketActivity` | Boolean | 5m/1h/6h/24h volume, txns, price change; 24h buys/sells/traders. Default `true`. |
| `includeTopHolders` + `topHoldersLimit` | Boolean + Integer | Largest holders with flags. Default off, 20 per token (max 50). |
| `includeTrades` + `tradesLimit` | Boolean + Integer | Newest trades per token. Default off, 20 per token (max 300). |
| `includeCreatorStats` | Boolean | Creator launch history + rug-risk score. Default off. |
| `includeCallouts` | Boolean | Trader callouts on each token. Default off. |
| **🔁 Monitoring** | | |
| `monitorMode` | Select | `off` (default), `new`, `newOrGraduated`. |
| `watchName` | String | Keeps separate memories for schedules on the same source. |
| `watchMinutes` / `pollIntervalSeconds` | Integer | Keep one run open for up to 60 minutes, polling every 10-300 s. |
| **📦 Output** | | |
| `maxResults` | Integer | Default `100`; `0` = everything the source lists. |
| `sortBy` | Select | pump.fun's order (default) or market cap, newest, oldest, curve, 24h volume, ATH drop, holders, liquidity, replies. |
| `compact` | Boolean | Core fields only — for AI agents and spreadsheets. |
| **🔔 Telegram alerts** | | |
| `telegramBotToken` / `telegramChatId` / `telegramMinMarketCapUsd` | Secret / String / Number | Sends delivered tokens to your own chat, 10 per message. |

#### Input JSON

```json
{
  "mode": "feed",
  "feed": "graduating",
  "maxResults": 50,
  "minBondingCurveProgress": 85,
  "maxTop10HoldersPercent": 35,
  "requireAnySocial": true,
  "includeCreatorStats": true
}
```

#### Pick the feed before anything else

The feed decides which tokens you see; filters only narrow it. Board feeds (`new`, `graduating`, `graduated`, `movers`, `charity`) are pump.fun's own ranked lists of up to 150 tokens. Listing feeds (`topMarketCap`, `recentlyTraded`, `mostReplies`, `recentlyReplied`, `topAth`, `newest`) page deeper, to 1,070 tokens. **Do:** `feed: "graduating"` + `minBondingCurveProgress: 85` for tokens about to migrate. **Don't:** `feed: "new"` + `minMarketCapUsd: 1000000` — a token minutes old rarely has that market cap, so the run ends empty.

#### Age is in minutes, percentages are 0-100

`maxAgeMinutes: 5` keeps tokens created in the last five minutes. Share filters take percent of supply: `maxDevHoldingsPercent: 5` drops tokens whose creator still holds more than 5%.

#### Use monitor mode for a launch feed, not a long watch

For a continuous new-token feed, schedule the actor every few minutes with `monitorMode: "new"`: each run returns only tokens it has not delivered before. `watchMinutes` keeps a single run open instead; it stops early when too few tokens match your filters to cover the run.

### ⬆️ Output

One row per token. A real row from the `graduating` feed (2026-10-14), shortened:

```json
{
  "mint": "BEVztnrkYCF2FBDJYkFu2Mh9MfdhLoF3MAaK86WEpump",
  "name": "VortexDeployer.com",
  "symbol": "Vortex",
  "creator": "GvWEm9wsUYAYk8BJX786whoBE7obxBs7qNz4iWt9u8T",
  "created_timestamp": "2026-10-11T13:43:26.000Z",
  "usd_market_cap": 34570,
  "price_usd": 0.00003457,
  "ath_market_cap_usd": 37504.81,
  "ath_drawdown_pct": 7.83,
  "bonding_curve_pct": 95.55,
  "is_graduated": false,
  "liquidity_usd": 7695.97,
  "twitter": "https://x.com/VortexDeployer",
  "website": "https://www.vortexdeployer.com/",
  "volume_24h_usd": 873.35,
  "txns_24h": 67,
  "buys_24h": 42,
  "sells_24h": 25,
  "price_change_24h_pct": -0.52,
  "creator_total_tokens": 134,
  "rug_risk_score": 39,
  "callout_count": 7,
  "pump_fun_url": "https://pump.fun/coin/BEVztnrkYCF2FBDJYkFu2Mh9MfdhLoF3MAaK86WEpump"
}
```

#### Fields

Fill measured on two local runs on 2026-10-14: **A** = 100 tokens from the `new` feed with the default add-ons; **B** = 25 tokens from `graduating` with every add-on on.

| Field | What it is | Fill A | Fill B |
|---|---|---:|---:|
| `mint`, `name`, `symbol`, `creator`, `created_timestamp`, `age_minutes` | Identity and age | 100% | 100% |
| `usd_market_cap`, `price_usd`, `ath_market_cap_usd`, `ath_drawdown_pct` | Market cap, price, all-time high | 100% | 100% |
| `market_cap_sol`, `price_sol` | SOL values (SOL-quoted tokens) | 89% | 80% |
| `bonding_curve_pct` | Curve progress 0-100 (100 when graduated) | 74% | 100% |
| `is_graduated`, `pool_address`, `bonding_curve` | Graduation flag, pool, curve account | 100% | 100% |
| `liquidity_usd` | Pool liquidity, or SOL in the curve | 100% | 100% |
| `twitter` / `telegram` / `website` | Social links the creator added | 57% / 1% / 33% | 92% / 28% / 80% |
| `holders`, `top10_holders_pct`, `snipers_holdings_pct`, `bundlers_holdings_pct` | Holder distribution | 97% | 100% |
| `dev_holdings_pct` | Creator's share of supply (null when pump.fun reports none) | 94% | 24% |
| `total_fees_sol`, `total_fees_usd` | Lifetime trading fees | 100% | 100% |
| `volume_24h_usd`, `txns_24h`, `buys_24h`, `sells_24h`, `traders_24h`, `price_change_24h_pct` | 24h market activity | 99% | 100% |
| `volume_5m_usd`, `txns_5m`, `price_change_5m_pct` | Last 5 minutes (null with no trade in the window) | 97% | 68% |
| `top_holders` | Largest holders: address, amount, % of supply, creator/sniper/bundler flags | — | 100% |
| `recent_trades` | Newest trades: side, trader, amounts, USD value, price, venue | — | 92% |
| `creator_total_tokens`, `creator_graduation_rate`, `creator_launches_24h`, `creator_reused_socials`, `rug_risk_score` | Creator history | — | 100% |
| `callouts`, `callout_count` | Trader callouts | — | 92% / 100% |
| `is_currently_live`, `livestream_title`, `num_participants` | Live stream; title and participant count are filled on the `live` feed (8 of 8 on a test run) | 100% / 0% / 0% | 100% / 0% / 4% |
| `security_verdict`, `is_banned`, `nsfw`, `is_mayhem`, `mayhem_state`, `program`, `quote_symbol` | Flags and launch details | 100% (`mayhem_state` 26%) | 96-100% |

`rug_risk_score` is our 0-100 composite from the creator's own history: 40% rapid launching (launches in the last 24 h, 10 or more = full weight), 30% failure to graduate (only with 3+ earlier launches), 20% share of banned launches, 10% socials reused across the creator's tokens. 0 means no history to judge.

Callouts mode adds a `callouts` list per token with the caller's username, wallet, X handle, followers, thesis, entry market cap, multiple, position value and PnL.

### How can I use pump.fun data?

- 🤖 **Trading bots** — feed `new` with `maxAgeMinutes: 5`, `requireAnySocial` and a low `maxDevHoldingsPercent` into your buy logic on a 1-minute schedule.
- 🎓 **Graduation hunters** — `graduating` + `minBondingCurveProgress: 90`, monitor mode `newOrGraduated` to be told the moment one migrates.
- 🛡️ **Risk screening** — look up a mint list with holder stats and creator history; drop anything with a high `rug_risk_score` or concentrated top-10 share.
- 🔍 **Wallet research** — follow serial launchers through creators mode and see how many of their tokens ever graduate.
- 📣 **Signal tracking** — callouts mode shows which tokens traders are calling, their entry market cap and current multiple.
- 📊 **Analysts and AI agents** — top-market-cap or recently-traded listings with 24h activity, exported to a sheet or queried through MCP.

### How much does it cost to scrape pump.fun?

Pump.fun Token Scraper is pay-per-result: **$0.45 per 1,000 tokens**, with every extra-data option included and no start fee. You are charged only for tokens written to the dataset; filtered, duplicate, already-delivered and not-found tokens cost nothing, and there is nothing else to pay.

| Tokens | Cost |
|---:|---:|
| 20 | $0.009 |
| 100 | $0.045 |
| 1,000 | $0.45 |
| 10,000 | $4.50 |

Speed measured with the default extra data (holder stats and market activity): 100 tokens in 26 seconds, 1,000 tokens in 4.5 minutes.

### Integrations, API, scheduling & MCP

- **Schedules:** run it every minute, hour or day from the **Schedules** tab; with monitor mode each run returns only tokens it has not delivered before.
- **Telegram:** add your bot token and chat id to get delivered tokens in a chat.
- **Webhooks:** fire a URL when a run finishes — push rows to your bot, CRM, Slack or a sheet.
- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable and Slack via [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client` — code on the [API tab](https://apify.com/scrapersdelight/pumpfun-token-scraper/api/python).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/scrapersdelight/pumpfun-token-scraper/api/mcp); `compact: true` keeps rows short.

### More scrapers for crypto research

<table>
<tr>
<td>🐦 <a href="https://apify.com/scrapersdelight/x-tweet-search-scraper">X (Twitter) Tweet Search Scraper</a> — what people say about a ticker</td>
<td>✈️ <a href="https://apify.com/scrapersdelight/telegram-channel-posts-scraper">Telegram Posts Scraper</a> — a token's Telegram channel history</td>
<td>🔎 <a href="https://apify.com/scrapersdelight/telegram-channel-search-scraper">Telegram Channel Search Scraper</a> — fresh posts by keyword</td>
</tr>
<tr>
<td>📊 <a href="https://apify.com/scrapersdelight/telegram-channel-stats-scraper">Telegram Channel Stats</a> — subscribers and engagement</td>
<td>👽 <a href="https://apify.com/scrapersdelight/reddit-search-scraper">Reddit Search Scraper</a> — posts by keyword and score</td>
<td>🧭 <a href="https://apify.com/scrapersdelight">All our actors</a></td>
</tr>
</table>

### Limits & empty runs

- **Depth:** board feeds hold up to 150 tokens; listing feeds and creator wallets page to 1,070 (all 1,070 on top market cap; 996 unique on recently traded, whose order shifts while it is read); search pages to 1,050 per term; the callout feed holds about 150 calls.
- **Speed:** pump.fun rate-limits each IP, so the actor paces itself at about 4 requests a second. Holder stats cost one request per token: 1,000 tokens took 4.5 minutes with them on; 1,070 tokens without them took 15 seconds.
- **Bonding-curve progress** is computed on pump.fun's standard curve; it is empty for Mayhem-mode tokens and other launchpads that use different curves, and 100 for graduated tokens.
- **Fresh tokens:** holder stats can be empty for roughly the first minute after launch (3 of 100 new-feed tokens on a test run); they are never filled with 0.
- **Market windows:** a 5 m or 1 h value is empty when the token had no trade in that window.
- **Not available:** KOL counts, insider share and social-link reuse across all of pump.fun, and lifetime volume, are not served by pump.fun's public API, so they are not in the rows.
- **Empty dataset:** your filters removed every token (the run summary lists how many per filter), every token was already delivered in monitor mode, or pump.fun refused requests for a while (nothing is charged — re-run in a few minutes).

### FAQ

#### How many tokens can Pump.fun Token Scraper return in one run?

Up to 150 from a board feed, 1,070 from a listing feed or creator wallet, and 1,050 per search term. Run several feeds or terms to go wider.

#### Can Pump.fun Token Scraper track new pump.fun launches automatically?

Yes. Schedule it on the `new` feed with `monitorMode: "new"`; each run delivers only tokens launched since the last delivery. Use `newOrGraduated` to also get a token again when it graduates.

#### Does Pump.fun Token Scraper show holders, snipers and bundlers?

Yes — `includeHolderStats` (on by default) adds holder count, top-10, creator, sniper and bundler share of supply and lifetime fees; `includeTopHolders` lists the wallets.

#### Can I look up specific pump.fun tokens?

Yes. Use `mode: "tokens"` and paste mint addresses or pump.fun coin URLs. Mints pump.fun does not know are listed in the run summary and not charged.

#### Can I use Pump.fun Token Scraper with the Apify API?

Yes. Start runs and read datasets with `apify-client` for [Node.js](https://apify.com/scrapersdelight/pumpfun-token-scraper/api/javascript) or [Python](https://apify.com/scrapersdelight/pumpfun-token-scraper/api/python).

#### Can I use Pump.fun Token Scraper through an MCP server?

Yes. Open the [MCP tab](https://apify.com/scrapersdelight/pumpfun-token-scraper/api/mcp), connect your client and ask for pump.fun tokens in plain language; `compact: true` returns the core fields only.

#### Do I need a pump.fun account, wallet or API key?

No. The actor reads pump.fun's public data; you pass a feed, search terms, mints or wallets.

#### Why did my Pump.fun Token Scraper run return no tokens?

Most often the filters removed everything — the run summary (`RUN_SUMMARY`) counts drops per filter. In monitor mode, nothing new may have launched since the last run. Rarely pump.fun refuses requests for a few minutes; nothing is charged and a re-run works.

#### How is Pump.fun Token Scraper different from other pump.fun scrapers?

One actor covers every feed, search, mint lookup, creator wallets and callouts, with holder distribution, 5m-24h market activity, top holders, trades and creator history on the same row at one price, plus filters on any numeric field and a monitor that re-alerts on graduation.

#### Is this investment advice?

No. Pump.fun Token Scraper returns raw market data for research and monitoring. Memecoins are extremely high-risk.

#### Your feedback

Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/scrapersdelight/pumpfun-token-scraper/issues/open) and we will look at it.

# Actor input Schema

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

Where the tokens come from. Feed mode reads the board you pick below; search, tokens and creators modes use the lists below.

## `feed` (type: `string`):

Used in Feed mode. Board feeds return pump.fun's own ranking (up to 150 tokens); listing feeds page deeper, up to 1,070 tokens.

## `searchTerms` (type: `array`):

Used in Search mode. Each term is searched on pump.fun's name/ticker search, e.g. "pepe", "dog", "ai agent". Up to 50 characters each.

## `searchAllTime` (type: `boolean`):

Off = pump.fun's default search (tokens from the last 7 days). On = search every token ever launched.

## `tokens` (type: `array`):

Used in Token lookup mode. Solana mint addresses or pump.fun coin URLs, e.g. "wjEYRUp7SowPSp3eEGozus9kmCBbzTMVpzd5NdQpump" or "https://pump.fun/coin/<mint>".

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

Used in Creator wallets mode. Solana wallet addresses; returns the tokens each wallet launched, newest first (up to 1,070 per wallet).

## `graduationState` (type: `string`):

Keep only tokens still on the bonding curve, or only graduated ones.

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

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

## `includeEvmTokens` (type: `boolean`):

pump.fun's movers board and search also list tokens on EVM chains (0x addresses). Off = Solana tokens only.

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

Keep tokens whose current market cap is at least this, e.g. 10000. Empty = no minimum.

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

Keep tokens whose current market cap is at most this, e.g. 69000 for tokens near graduation. Empty = no maximum.

## `minAgeMinutes` (type: `number`):

Keep tokens created at least this many minutes ago. Empty = no minimum.

## `maxAgeMinutes` (type: `number`):

Keep tokens created within the last N minutes, e.g. 30. Empty = any age.

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

0-100. Set 85 to catch tokens about to graduate. Graduated tokens count as 100.

## `maxBondingCurveProgress` (type: `number`):

0-100. Set 30 for early tokens only.

## `minAthDrawdownPercent` (type: `number`):

Keep tokens trading at least this far below their all-time-high market cap, e.g. 80 for post-pump dumps.

## `minHolders` (type: `integer`):

Keep tokens with at least this many holder wallets. Reads holder stats for each token.

## `maxTop10HoldersPercent` (type: `number`):

Drop tokens whose ten largest wallets hold more than this share of supply, e.g. 35.

## `maxDevHoldingsPercent` (type: `number`):

Drop tokens whose creator wallet still holds more than this share of supply, e.g. 5.

## `minVolume24hUsd` (type: `number`):

Keep tokens that traded at least this much in the last 24 hours.

## `requiredSocials` (type: `array`):

Keep only tokens that link every social picked here.

## `requireAnySocial` (type: `boolean`):

Keep only tokens that link X, Telegram or a website.

## `includeKeywords` (type: `array`):

Keep tokens whose name or ticker contains any of these words, e.g. "dog", "ai".

## `excludeKeywords` (type: `array`):

Drop tokens whose name or ticker contains any of these words, e.g. "test".

## `excludeCreators` (type: `array`):

Drop every token launched by these wallets.

## `programs` (type: `array`):

Keep only tokens on these launch programs, e.g. "pump", "meteora_dbc", "raydium_launchpad". Empty = all.

## `fieldFilters` (type: `object`):

Min/max on any numeric output field, e.g. {"snipers_holdings_pct": {"max": 10}, "liquidity_usd": {"min": 5000}, "txns_1h": {"min": 50}}. A token missing the field is dropped.

## `includeHolderStats` (type: `boolean`):

Holder count, top-10 / creator / sniper / bundler share of supply and lifetime fees (one extra request per token).

## `includeMarketActivity` (type: `boolean`):

Volume, transactions and price change for 5 minutes, 1 hour, 6 hours and 24 hours, plus 24h buys, sells, buyers and sellers.

## `includeTopHolders` (type: `boolean`):

The largest holder wallets with their share of supply and creator / sniper / bundler flags.

## `topHoldersLimit` (type: `integer`):

How many holders to list (pump.fun serves up to 50).

## `includeTrades` (type: `boolean`):

The newest trades on each token: side, trader wallet, amounts, USD value, price and venue.

## `tradesLimit` (type: `integer`):

How many of the newest trades to attach per token (100 per request).

## `includeCreatorStats` (type: `boolean`):

The creator wallet's launch count, graduated launches, graduation rate, best ATH, banned launches, launches in 24 h, reused socials and a 0-100 rug-risk score.

## `includeCallouts` (type: `boolean`):

Callouts traders posted on the token: thesis, time, entry price, multiple reached.

## `monitorMode` (type: `string`):

Remembers delivered tokens in a named store between runs. Filtered tokens are not remembered, so they come through later if they start to match.

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

Optional name for this monitor (letters, digits, dashes). Give two schedules on the same feed different names so they keep separate memories.

## `watchMinutes` (type: `integer`):

0 = read once and finish. 1-60 = keep the run open and poll the source, delivering each new token as it appears. Ends early if too few tokens match to cover the run.

## `pollIntervalSeconds` (type: `integer`):

How often a watching run re-reads the source.

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

Tokens to deliver in this run. 0 = everything the source lists (boards up to 150, listings and creators up to 1,070, search up to 1,050 per term).

## `sortBy` (type: `string`):

Orders the delivered tokens. Ignored while watching.

## `compact` (type: `boolean`):

Core fields only (mint, name, ticker, market cap, price, curve, socials, holders, 24h volume, link) — handy for AI agents and spreadsheets.

## `telegramBotToken` (type: `string`):

Your bot's token from @BotFather. Leave empty for no alerts.

## `telegramChatId` (type: `string`):

The chat, group or channel id that receives the alerts.

## `telegramMinMarketCapUsd` (type: `number`):

Alert only for delivered tokens whose market cap is at least this. 0 = every delivered token (up to 250 per run, 10 per message).

## `proxyConfiguration` (type: `object`):

Not needed: the actor reads pump.fun directly and steps to a proxy by itself only if pump.fun refuses. A proxy set here is used as that fallback.

## Actor input object example

```json
{
  "mode": "feed",
  "feed": "new",
  "searchAllTime": false,
  "graduationState": "any",
  "includeNsfw": false,
  "includeEvmTokens": false,
  "requireAnySocial": false,
  "includeHolderStats": true,
  "includeMarketActivity": true,
  "includeTopHolders": false,
  "topHoldersLimit": 20,
  "includeTrades": false,
  "tradesLimit": 20,
  "includeCreatorStats": false,
  "includeCallouts": false,
  "monitorMode": "off",
  "watchMinutes": 0,
  "pollIntervalSeconds": 20,
  "maxResults": 20,
  "sortBy": "source",
  "compact": false,
  "telegramMinMarketCapUsd": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `tokens` (type: `string`):

One row per token: mint, name, ticker, creator, market cap, price, bonding curve, graduation, socials, plus the holder, market-activity, trade, creator and callout data you switched on.

## `summary` (type: `string`):

Counts for the run: delivered, filtered (by reason), duplicates, already delivered by earlier monitor runs, not-found mints, requests and field fill.

# 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 = {
    "mode": "feed",
    "feed": "new",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/pumpfun-token-scraper").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 = {
    "mode": "feed",
    "feed": "new",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/pumpfun-token-scraper").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 '{
  "mode": "feed",
  "feed": "new",
  "maxResults": 20
}' |
apify call scrapersdelight/pumpfun-token-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/pumpfun-token-scraper"
        }
    }
}
```

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/F8U08Nxu94PklviC5/builds/SAOBPQS6VsWXSCneM/openapi.json