# Pump.fun Token Risk Analyzer & Creator Monitor (`thescrapelab/pumpfun-token-risk-creator-monitor`) Actor

Analyze Pump.fun tokens with evidence-backed risk scores, creator launch history, platform safety signals, market data, and metadata checks. Monitor bans, graduation status, risk scores, and market-cap changes, then export structured results through Apify.

- **URL**: https://apify.com/thescrapelab/pumpfun-token-risk-creator-monitor.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 token analyses

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

Analyze Pump.fun tokens before adding them to a research workflow or watchlist. This Pump.fun token risk analyzer combines platform safety signals, creator launch history, market data, and metadata checks into an evidence-backed risk score, then returns structured records ready for export or API integration.

Use the Actor as a Pump.fun creator monitor to identify rapid launching, banned launch history, repeated websites or social links, token graduation, changing market cap, and material risk changes. Every score includes its evidence and coverage, so missing public data is not presented as low risk.

### Key features

- Analyze a Pump.fun URL or Solana mint address.
- Discover recent Pump.fun token launches automatically.
- Score platform, creator, market, and transparency risk signals.
- Inspect recent launch history for each observed creator.
- Detect banned tokens, security verdicts, graduation status, and metadata gaps.
- Monitor risk-score, market-cap, ban, security, and graduation changes between runs.
- Export structured results from the Apify dataset in JSON, CSV, Excel, XML, or RSS formats.
- Run from Apify Console, the API, schedules, webhooks, or integrations.

### Use cases

- **Token due diligence** — screen a newly discovered Pump.fun token before deeper manual research.
- **Creator research** — compare launch frequency, banned launches, completed launches, and reused links.
- **Token watchlists** — track a fixed set of mint addresses and detect material changes over time.
- **Launch discovery** — find and filter recent tokens by active or completed bonding-curve status.
- **Risk dashboards** — feed normalized token, creator, and monitoring data into internal tools.
- **Research alerts** — combine repeated runs with Apify schedules, webhooks, or external automation.

### Input options

Run the Actor with specific Pump.fun token URLs or Solana mint addresses, discover recent launches, or combine both methods.

| Field | Description | Default |
| --- | --- | --- |
| `tokenUrlsOrMints` | Pump.fun token URLs or Solana mint addresses. Duplicate targets are removed. | `[]` |
| `discoverLatest` | Fill unused capacity with recent Pump.fun launches. | `true` |
| `bondingCurveState` | Keep `any`, `active`, or `complete` tokens. | `any` |
| `maxTokens` | Maximum token analyses and paid token events, from 1 to 100. | `1` |
| `includeCreatorHistory` | Inspect prior launches for each observed creator. | `true` |
| `monitoringEnabled` | Compare current token snapshots with previous runs. | `false` |

The input form uses safe defaults for creator-history depth, monitoring storage, request concurrency, and source timeouts. Existing API integrations can continue supplying those advanced keys, but most users do not need to change them.

Copyable input for a one-token discovery run:

```json
{
  "discoverLatest": true,
  "maxTokens": 1
}
```

The Actor accepts at most 100 unique tokens per run. If both explicit targets and discovery are enabled, valid explicit targets are processed first and recent launches fill the remaining capacity.

### Output dataset

Results are saved to the default Apify dataset. A run can produce four record types:

| Record type | What it contains |
| --- | --- |
| `token` | A self-contained token assessment with a readable summary, risk signals, evidence coverage, creator context, market data, safety fields, links, and monitoring status. |
| `creator` | Creator launch totals, recent velocity, banned and graduation rates, rapid-launching status, and reused websites or social links. |
| `change` | A readable summary, changed-field list, and previous/current values for material monitoring differences. |
| `error` | A readable target-level explanation when a token is invalid, filtered out, unavailable, or cannot be analyzed. |

Example token result:

```json
{
  "recordType": "token",
  "observedAt": "2026-09-16T09:33:44.354Z",
  "subject": "Example token (EXAMPLE)",
  "summary": "43/100 observed-signal score (high); 2 rule-based risk signals detected; 70% evidence coverage. Not a safety rating.",
  "mint": "EXAMPLE_MINT_ADDRESS",
  "tokenUrl": "https://pump.fun/coin/EXAMPLE_MINT_ADDRESS",
  "name": "Example token",
  "symbol": "EXAMPLE",
  "creator": "EXAMPLE_CREATOR_ADDRESS",
  "assessmentStatus": "scored",
  "riskScore": 43,
  "riskBand": "high",
  "riskSignalCount": 2,
  "topRiskSignals": [
    "10 launches were observed in the last 24 hours."
  ],
  "primaryRiskCategory": "creator",
  "coveragePercent": 70,
  "categoryScores": {
    "platform": { "points": 0, "available": 20 },
    "creator": { "points": 25, "available": 35 },
    "market": { "points": 0, "available": 0 },
    "transparency": { "points": 5, "available": 15 }
  },
  "evidence": [
    {
      "category": "creator",
      "signal": "rapid_launching",
      "points": 25,
      "detail": "10 launches were observed in the last 24 hours."
    }
  ],
  "graduationStatus": "active",
  "tokenAgeHours": 1.6,
  "socialLinkCount": 1,
  "creatorHistoryAvailable": true,
  "creatorTotalLaunches": 10,
  "creatorLaunchesLast24Hours": 10,
  "creatorBannedLaunches": 0,
  "creatorCompletedLaunches": 2,
  "changeStatus": "disabled"
}
```

The risk score is returned only when at least 60% of the weighted checks are available. It measures triggered rule-based signals, not whether a token is safe or likely to perform well. Otherwise `riskScore` is `null` and `riskBand` is `unknown`, preventing incomplete public data from being mistaken for a clean assessment.

### Risk signals

The Pump.fun token risk score groups available evidence into four categories:

- **Platform** — ban state, initialization state, and available security verdicts.
- **Creator** — launch velocity, banned launch history, and repeated website or social links.
- **Market** — drawdown from observed all-time-high market cap and trading inactivity.
- **Transparency** — missing or incomplete website, social, image, and description metadata.

Scores are heuristic research indicators. Review the evidence array and coverage percentage instead of relying on the score alone.

### Monitor Pump.fun token changes

Set `monitoringEnabled` to `true`. The Actor automatically reuses its monitoring store across runs. The first observation becomes the baseline. Later runs return a `change` record when the Actor detects:

- a different risk band;
- a risk-score movement of at least 10 points;
- a market-cap movement of at least 20%;
- a changed ban, graduation, or security-verdict state.

Monitoring state is compact and retains the 500 most recently observed token snapshots. The Actor does not create a schedule automatically; choose the frequency in Apify Console or trigger runs through the API.

### Pricing

This Actor uses Pay Per Event pricing:

- **$0.0007** when a run starts;
- up to **$0.004** for each successfully delivered token analysis;
- automatic per-token discounts for eligible higher-volume Apify tiers.

Creator-history and change records are included with the token analysis. Error and status records do not add a token event. If the run's maximum charge is reached, the Actor stops before additional creator-history work and returns the successfully completed results with a `partial_budget` summary.

### Run with the Apify API

```python
from apify_client import ApifyClient

TOKEN = "YOUR_APIFY_TOKEN"
ACTOR_ID = "thescrapelab/pumpfun-token-risk-creator-monitor"

apify_client = ApifyClient(TOKEN)
actor_client = apify_client.actor(ACTOR_ID)

run_input = {
    "discoverLatest": True,
    "maxTokens": 3,
}

call_result = actor_client.call(run_input=run_input)

if call_result is None:
    raise RuntimeError("Actor run failed")

dataset_client = apify_client.dataset(call_result.default_dataset_id)
items = dataset_client.list_items().items

for item in items:
    print(item)
```

The same dataset is available through Apify's API, integrations, and export interface.

### Data source and limitations

The Actor uses publicly reachable Pump.fun frontend data. Source availability, response fields, or access rules can change without notice. When a target cannot be processed, the Actor returns a clear error record instead of silently presenting incomplete results.

Token markets are volatile. Public fields can be missing, creator history is limited to the selected observation window, and platform safety labels can change after a run. Always verify important findings independently.

This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Pump.fun. Use the data in accordance with applicable laws and the source website's terms. The output is not financial, investment, legal, or compliance advice.

### Frequently asked questions

#### Can I analyze one Pump.fun token by mint address?

Yes. Add the mint address or full Pump.fun token URL to `tokenUrlsOrMints`, disable discovery, and use `maxTokens: 1`.

#### Can I discover recent Pump.fun launches?

Yes. Leave `discoverLatest` enabled and choose the number of tokens with `maxTokens`. Use `bondingCurveState` to keep all, active, or completed tokens.

#### Does the Actor monitor tokens continuously?

The Actor compares snapshots between runs but does not create a schedule. Enable monitoring and run it at your preferred interval through Apify schedules or the API; the default monitoring store is reused automatically.

#### Does a low score guarantee that a token is safe?

No. The score summarizes observed public signals and is not a guarantee, audit, endorsement, or prediction. Always inspect the evidence and verify important decisions independently.

### Support

If an execution behaves unexpectedly, open an issue on the Actor's **Issues** tab. Include the execution ID, relevant non-secret input, expected result, and observed result. Never include API tokens, wallet secrets, private keys, or other credentials.

# Actor input Schema

## `tokenUrlsOrMints` (type: `array`):

Add Pump.fun token URLs or Solana mint addresses to analyze. Duplicate targets are removed automatically, with up to 100 unique tokens per run.

## `discoverLatest` (type: `boolean`):

Find recent Pump.fun launches when the target list contains fewer tokens than the maximum token limit.

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

Analyze all matching tokens, only active bonding curves, or only completed and graduated tokens.

## `maxTokens` (type: `integer`):

Set the maximum number of token analyses and paid token events for this run. The hard limit is 100 tokens.

## `includeCreatorHistory` (type: `boolean`):

Inspect each token creator's observed launch history for rapid launches, banned tokens, completed launches, and reused links.

## `creatorHistoryLimit` (type: `integer`):

Set the maximum number of prior launches inspected for each unique creator, from 1 to 70.

## `monitoringEnabled` (type: `boolean`):

Save compact token snapshots and return change records when risk, market cap, ban, security, or graduation signals change.

## `stateStoreName` (type: `string`):

Choose the named key-value store used for snapshots. Reuse the same name in later runs to compare token changes.

## `maxConcurrency` (type: `integer`):

Set simultaneous source requests from 1 to 4. The default of 2 balances speed, source stability, memory, and cost.

## `requestTimeoutSecs` (type: `integer`):

Set how many seconds one Pump.fun source request may take before it is treated as timed out.

## Actor input object example

```json
{
  "tokenUrlsOrMints": [],
  "discoverLatest": true,
  "bondingCurveState": "any",
  "maxTokens": 1,
  "includeCreatorHistory": true,
  "creatorHistoryLimit": 10,
  "monitoringEnabled": false,
  "stateStoreName": "pumpfun-token-risk-monitor-state",
  "maxConcurrency": 2,
  "requestTimeoutSecs": 8
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Export self-contained token assessments plus supporting creator, change, and error records. Use the overview or detailed dataset view in Apify Console.

## `runSummary` (type: `string`):

Review the readable result message, dataset totals, partial-result status, source requests, monitoring state, and estimated run charge.

# 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("thescrapelab/pumpfun-token-risk-creator-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/pumpfun-token-risk-creator-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 '{}' |
apify call thescrapelab/pumpfun-token-risk-creator-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/pumpfun-token-risk-creator-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/PQQdkZX8oudpBjOxb/builds/dr8uHki5Y1oVkzAym/openapi.json