# Pump.fun New Token Listings Scraper (`automation-lab/pumpfun-new-token-listings-scraper`) Actor

Monitor new Pump.fun token launches and export mint, creator, bonding-curve, market-cap, media, and canonical listing URL records.

- **URL**: https://apify.com/automation-lab/pumpfun-new-token-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.36 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Pump.fun New Token Listings Scraper

Monitor newly launched Pump.fun tokens and export clean listing records for research, screening, dashboards, and scheduled alerts.

This Actor uses the public Pump API surface to collect newest-first launch data without a browser. Each dataset row includes the mint address, name, symbol, launch time, creator, bonding-curve state, reserves, market-cap fields, media, socials, and canonical listing URL.

### What does this Pump.fun scraper do?

Pump.fun New Token Listings Scraper turns the changing public launch feed into typed, integration-ready records.

It can:

- collect up to 1,000 newest matching launches;
- select active or completed bonding curves;
- limit results to launches from a recent time window;
- apply a minimum USD market-cap threshold;
- exclude NSFW-marked listings by default;
- preserve stable mint addresses and canonical Pump.fun URLs;
- run once or on an Apify schedule.

The Actor returns listings, not trade-by-trade events or investment recommendations.

### Who is it for

- **Crypto researchers** building a current launch universe.
- **Trading-data teams** feeding token candidates into independent risk models.
- **Analysts** comparing creators, market caps, and bonding-curve states.
- **Automation builders** triggering alerts for newly observed mints.
- **Data engineers** loading normalized Pump.fun data into warehouses or dashboards.

### Why use this Pump API extractor?

The public source response contains many source-specific field names and timestamps. This Actor normalizes them into predictable camelCase dataset rows, converts timestamps to ISO 8601, adds canonical listing URLs, deduplicates by mint, validates response shapes, and retries temporary upstream failures.

The implementation is HTTP-only, so runs avoid browser overhead and unnecessary image downloads.

### What data can I extract?

| Group | Fields |
| --- | --- |
| Identity | `mint`, `name`, `symbol`, `description` |
| Launch | `launchTimestamp`, `lastTradeTimestamp`, `scrapedAt` |
| Creator | `creator`, `creatorUsername` |
| Bonding curve | `bondingCurveState`, `bondingCurve`, `associatedBondingCurve`, `initialized` |
| Market | `marketCapSol`, `marketCapUsd`, `allTimeHighMarketCap` |
| Reserves | virtual and real SOL/token reserves, `totalSupply` |
| Media | `imageUrl`, `metadataUrl`, `website`, `twitter`, `telegram` |
| Context | reply count, NSFW/banned flags, protocol, pool address |
| Source | `listingUrl` |

Optional source values are returned as `null` when Pump.fun does not expose them.

### How to scrape new Pump.fun listings

1. Open the Actor in Apify Console.
2. Set **Maximum listings** to the number of records you need.
3. Choose any, active, or completed bonding curves.
4. Keep NSFW listings excluded unless your workflow explicitly needs them.
5. Optionally set launch age or minimum market cap filters.
6. Click **Start**.
7. Open the **Dataset** tab to preview or download JSON, CSV, Excel, XML, RSS, or JSONL.

A useful first run is:

```json
{
  "maxItems": 20,
  "bondingCurveState": "any",
  "includeNsfw": false
}
```

### Input parameters

#### `maxItems`

Maximum matching records to save. Allowed range: 1–1,000. Default: 50.

#### `bondingCurveState`

- `any`: return either state;
- `active`: only tokens still on a Pump.fun bonding curve;
- `complete`: only completed curves.

#### `includeNsfw`

Whether the source may return listings marked NSFW. Default: `false`.

#### `minMarketCapUsd`

Optional non-negative USD market-cap floor. Listings without a USD market-cap value do not match this filter.

#### `maxAgeMinutes`

Optional positive launch-age window. For example, `60` limits accepted rows to launches from approximately the last hour.

Strict filters can produce fewer rows than `maxItems`. The Actor scans a bounded number of newest pages rather than crawling unlimited history.

### Output example

```json
{
  "mint": "ExampleMint111111111111111111111111111111111",
  "name": "Example Token",
  "symbol": "EXMPL",
  "description": "An example community token.",
  "launchTimestamp": "2025-01-15T12:00:00.000Z",
  "creator": "ExampleCreator111111111111111111111111111",
  "creatorUsername": "examplecreator",
  "bondingCurveState": "active",
  "bondingCurve": "ExampleCurve11111111111111111111111111111",
  "marketCapSol": 31.25,
  "marketCapUsd": 4520.75,
  "imageUrl": "https://pump.fun/example-token.png",
  "listingUrl": "https://pump.fun/coin/ExampleMint111111111111111111111111111111111",
  "nsfw": false,
  "banned": false,
  "scrapedAt": "2025-01-15T12:02:00.000Z"
}
```

The full schema also includes reserve, supply, ATH market-cap, social, metadata, pool, protocol, reply, and trade-time fields.

### Recurring monitoring and alerts

Create an Apify schedule to run every few minutes, then connect the run dataset to a webhook, Make, Zapier, Slack, email, a database, or your own alert service.

Use mint as the stable deduplication key across runs. A typical alert workflow is:

1. run with `maxAgeMinutes` matching the schedule interval;
2. compare mints against previously seen values;
3. apply your independent risk and liquidity checks;
4. notify only on candidates that pass those checks.

The Actor itself does not persist cross-run seen state or send trading signals.

### How much does it cost to scrape Pump.fun token listings?

The Actor uses pay-per-event pricing: one **start** event per run and one **item** event per saved listing. The current source configuration starts at $0.005 per run. The exact item tier shown in Apify Console applies to your account usage tier.

At the BRONZE rate of $0.007264 per item:

A 10-listing run emits one start event and 10 item events; a 50-listing run emits one start event and 50 item events; a 100-listing run emits one start event and 100 item events. The Apify Console estimate applies the active tier to those event counts.

The $0.005 start price and $0.007264 BRONZE item price are the active unit rates. Final live Console pricing is authoritative and can vary by tier.

### API usage with cURL

Set `APIFY_TOKEN` in your environment, then run:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~pumpfun-new-token-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":25,"bondingCurveState":"active","includeNsfw":false}'
```

To wait for completion and retrieve dataset items, use the synchronous dataset-items endpoint:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~pumpfun-new-token-listings-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":20,"maxAgeMinutes":60}'
```

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pumpfun-new-token-listings-scraper').call({
  maxItems: 50,
  bondingCurveState: 'any',
  includeNsfw: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/pumpfun-new-token-listings-scraper').call(
    run_input={
        'maxItems': 50,
        'bondingCurveState': 'active',
        'includeNsfw': False,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/pumpfun-new-token-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this equivalent JSON configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/pumpfun-new-token-listings-scraper"
    }
  }
}
```

Example prompts:

- “Collect the 25 newest safe Pump.fun listings and summarize their bonding-curve states.”
- “Return active-curve launches from the last hour as JSON.”
- “Extract mints, creators, USD market caps, and listing URLs for my research pipeline.”

### Integrations

Common destinations include:

- Apify webhooks for run-completed automation;
- Google Sheets for lightweight review;
- BigQuery, Snowflake, or PostgreSQL for history;
- Make and Zapier for no-code alerts;
- Slack or Discord through your own webhook workflow;
- notebooks and quantitative research pipelines through the dataset API.

### Reliability and retry behavior

Requests have a 20-second timeout. Network errors, HTTP 429, and temporary 5xx responses receive up to three attempts with exponential backoff and jitter. Stable client errors, malformed responses, and invalid inputs fail clearly.

The Actor checks that the upstream response is JSON and contains a list. It does not silently treat a challenge page or server error as an empty feed.

### Limits

- Results reflect the public Pump.fun feed at run time.
- Pump.fun can change fields, rate limits, or endpoint behavior.
- Pagination is bounded to the newest 1,000 scanned records.
- Filters may yield fewer rows than requested.
- Market-cap and reserve values are source-provided snapshots, not independently verified valuations.
- Social links and media may be absent, inaccurate, or user-submitted.
- The Actor does not download linked media or metadata files.
- No historical archive, trade stream, risk score, or financial advice is provided.

### Responsible use and legality

This Actor accesses publicly available listing data. You are responsible for complying with Pump.fun terms, applicable laws, and the rules of downstream services.

Token listings and linked content are user-generated. Treat them as untrusted data. Do not use the output to facilitate fraud, harassment, market manipulation, or unlawful profiling. Verify financial facts independently before making decisions.

### Troubleshooting

#### Why did I receive fewer items than `maxItems`?

Your filters may exclude most recent launches, or the bounded newest window may contain fewer matches. Relax `maxAgeMinutes`, lower `minMarketCapUsd`, or select `any` bonding-curve state.

#### Why did the run fail with a Pump.fun API error?

The public source may be temporarily unavailable or rate-limited. The Actor already retries temporary failures. Wait and run again rather than increasing concurrency.

#### Why is a field `null`?

Pump.fun does not expose every optional media, social, username, pool, or market field on every listing. Null values preserve an honest stable schema.

#### Does this Actor monitor continuously?

Each run takes a current snapshot. Use Apify schedules and external deduplication to build continuous monitoring.

### FAQ

#### Does it require a proxy or Pump.fun account?

No. The current implementation uses a public structured endpoint directly and does not expose a proxy mode.

#### Can I collect completed bonding curves only?

Yes. Set `bondingCurveState` to `complete`.

#### Can I include NSFW listings?

Yes. Explicitly set `includeNsfw` to `true`.

#### Is output ordered newest first?

The source is requested newest first. Filtering preserves that order among accepted records.

#### Is this trading advice?

No. Output is source data for independent research. New tokens can be highly volatile or fraudulent.

### Related Automation Lab actors

For cross-market contract research rather than token launches, see [Polymarket Kalshi Arbitrage Monitor](https://apify.com/automation-lab/polymarket-kalshi-arbitrage-monitor).

For generic webpage change snapshots rather than Pump.fun records, see [Website HTML & Text Change Monitor](https://apify.com/automation-lab/website-html-text-change-monitor).

### Support

If a run fails, include the run URL, non-secret input, expected result count, and the relevant log excerpt in your Apify issue. Do not include API tokens or private webhook URLs.

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of matching token listing records to save (1–1000). Strict filters may return fewer records.

## `bondingCurveState` (type: `string`):

Return all tokens, tokens still on the Pump.fun bonding curve, or tokens whose curve is complete.

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

Whether Pump.fun listings marked NSFW may be returned.

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

Optional minimum current USD market capitalization. Listings without a USD value do not match.

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

Optional maximum age of each launch in minutes, useful for alerting and recent-token workflows.

## Actor input object example

```json
{
  "maxItems": 20,
  "bondingCurveState": "any",
  "includeNsfw": false
}
```

# Actor output Schema

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

Newest Pump.fun token listings in the overview view.

# 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 = {
    "maxItems": 20,
    "bondingCurveState": "any",
    "includeNsfw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pumpfun-new-token-listings-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 = {
    "maxItems": 20,
    "bondingCurveState": "any",
    "includeNsfw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pumpfun-new-token-listings-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 '{
  "maxItems": 20,
  "bondingCurveState": "any",
  "includeNsfw": false
}' |
apify call automation-lab/pumpfun-new-token-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/pumpfun-new-token-listings-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/7RlwcQG0veJBUOkxx/builds/7LOYiwQqrrcyfCMen/openapi.json