# Solana & Pump.fun Token Autopsy: Bundle & Rug Risk Scanner (`informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner`) Actor

Read-only Solana & Pump.fun rug-risk scanner: mint/freeze authority, liquidity depth, buy/sell flow, dump simulation and a SKIP/WATCH verdict per token. Holder & bundle data with your RPC.

- **URL**: https://apify.com/informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner.md
- **Developed by:** [Almandine Data](https://apify.com/informed_almandine_vzb) (community)
- **Categories:** AI, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 token autopsies

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

## Solana & Pump.fun Token Autopsy: Bundle & Rug Risk Scanner

Paste a contract address, get a structured post-mortem before you even open a chart. This Actor pulls live
DexScreener market data and Solana on-chain account state for every token you give it (or for whatever is
trending and boosted right now), runs a fixed set of deterministic risk rules, and returns one clean row per
token with a 0-10 `autopsyScore`, ranked red flags, and a `SKIP` / `WATCH` / `VALID_SETUP` label.

**Without your own RPC the best possible verdict is `WATCH`** (score capped at 7.0, `confidence: limited`),
because holder concentration has not been checked. A default run full of `WATCH` and `SKIP` rows is working as
designed; add `rpcUrl` to unlock `VALID_SETUP`.

It is built for people who already ask Claude, ChatGPT, or a Telegram bot "is this token a rug?" and are tired
of copy-pasting numbers out of five browser tabs. Every row carries a `claudePromptContext` string so an AI
agent can reason over facts instead of vibes.

> **Read-only. No wallets, no private keys, no trading, no signing.** Output is analytical research data from
> public sources. It is **not financial advice** and never tells you to buy anything.

### Holder analysis is an optional add-on (off by default)

Holder concentration needs `getTokenLargestAccounts`, and the free public Solana RPC rate-limits that call so
hard that results from it are unreliable. Rather than hand you half-filled numbers, the Actor **skips the holder
lookup entirely unless you bring your own RPC URL** (a free Helius, QuickNode, or Triton key is enough).

- **Without `rpcUrl` (default):** market, flow, liquidity, mint/freeze authority, dump simulation, and verdict
  are all computed. `bundleSuspectScore` is `null` with `bundleDataStatus: partial_no_rpc`, because the bundle
  signal depends on holder shape and a `0` would wrongly read as clean. `top10HoldersPct` and `top1HolderPct` are `null`,
  `holderDataStatus` is `skipped_no_rpc`, and the two holder rules report `pass: null` and do **not** count
  against `autopsyScore`. Because concentration is unverified, `autopsyScore` is capped at **7.0**, `confidence` is `limited`,
  `verdict` is **capped at `WATCH`**, and a
  `holder check skipped, verify concentration before acting` note is added to `redFlags`.
- **With `rpcUrl`:** holder %, `largestHolders` (pool vault excluded), and the holder rules switch on.
  `holderDataStatus` is `ok`, or `rate_limited` if your RPC refuses the call (then the `WATCH` cap still applies).
  Only `ok` rows can reach `VALID_SETUP`.
- **Price is the same either way:** $2.50 per 1,000 autopsy rows. Holder data is never charged extra.

### What you get per token

- **Market:** `priceUsd`, `marketCapUsd`, `liquidityUsd`, `liquidityToMcapPct`, `ageHours`, `dexId`
  (`pumpfun`, `pumpswap`, `raydium`, `meteora`, `orca`...), `pairAddress`, `pairUrl`.
- **Flow:** `volume5mUsd` / `volume1hUsd` / `volume24hUsd`, buys and sells for 5m / 1h / 24h,
  `buySellRatio1h`, `priceChange5mPct` / `1hPct` / `24hPct`.
- **On-chain safety:** `mintAuthorityRevoked` and `freezeAuthorityRevoked` read straight from the mint account
  (`getMultipleAccounts`, `jsonParsed`).
- **Holders:** `top10HoldersPct` and `top1HolderPct` with the liquidity-pool vault excluded, plus a
  `largestHolders` table (`getTokenLargestAccounts`). Optional, needs your own `rpcUrl`.
- **Bundle heuristic (with your RPC):** `bundleSuspectScore` 0-100, raised by clusters of equally sized top
  wallets, heavy top-10 concentration, very young thin pools, and lopsided buy pressure. `null` plus
  `bundleDataStatus` explaining why when holders are not checked.
- **Rules:** `ruleChecks` object, one entry per rule with `pass`, `value`, and `limit`.
- **Verdict:** `autopsyScore` (capped at 7.0 without holder data), `rawScore` (same formula, uncapped, so you can rank
  tokens inside a default run), `confidence` (`high` with holder data, `limited` without), `verdict`, `redFlags` (most dangerous first), `greenFlags`.
- **Dump simulation:** `graduationDumpSimulation` estimates price impact if the top 5 holders, or 1% / 5% /
  10% of supply, are market-sold into the current pool (constant-product approximation).
- **AI context:** `claudePromptContext`, a one-paragraph factual summary ready to paste into any LLM.

### Why not just use DexScreener and Solscan?

| Task | Manual tab-juggling | This Actor |
|---|---|---|
| Check 60 trending tokens | 60 x (DexScreener + Solscan holders (with your RPC) + authority check) = an afternoon | One run, about 15-60 seconds |
| Exclude the pool vault from holder % (with your RPC) | Eyeball which wallet is the LP | Matched automatically against pooled base |
| Mint / freeze authority | Open the token account, read raw fields | Boolean columns |
| Apply *your* thresholds | Mental math every time | `ruleChecks` with your limits |
| Feed an AI agent | Copy-paste screenshots | Structured JSON + `claudePromptContext` |
| Repeat every 15 minutes | Not realistic | Apify Schedules + webhooks |

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | `string` | `"autopsy_and_trending"` | 'autopsy_and_trending' autopsies your mints plus trending/boosted Solana tokens; 'mints_only' only your list; 'trending_discovery' only DexScreener boosts, profiles and search results. |
| `mintAddresses` | `array` | `["pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7` | Solana token mint addresses (CAs), DexScreener pair/token URLs, or pump.fun/coin URLs. |
| `searchQueries` | `array` | `["pump", "pumpswap", "raydium", "solana ` | Free-text DexScreener searches used to discover more Solana pairs (non-Solana results are dropped). |
| `dexFilter` | `array` | `[]` | Keep only these DexScreener dexIds (e.g. pumpfun, pumpswap, raydium, meteora, orca). Empty = all. |
| `maxTop10HoldersPct` | `number` | `25` | Rule: top 10 wallets (excluding the pool vault) may hold at most this % of supply. |
| `maxTop1HolderPct` | `number` | `8` | Rule: the largest non-pool wallet may hold at most this % of supply. |
| `minLiquidityUsd` | `number` | `5000` | Rule: minimum pooled liquidity in USD. |
| `minVolume1hUsd` | `number` | `2500` | Rule: minimum 1-hour trading volume in USD. |
| `rpcUrl` | `string` | `""` | Holder analysis (bring your own RPC: Helius/QuickNode/Triton). Optional add-on. Paste your own read-only Solana RPC URL to enable top-10/top-1 holder analysis, pool-vault exclusion and the holder rules. Empty = holder lookup skipped (holderDataStatus: skipped_no_rpc). No extra charge. |
| `maxItems` | `integer` | `65` | Maximum tokens to autopsy (each is one billed token-autopsy event). |

Run with `{}` and you get roughly 60+ live autopsies: the PUMP token plus everything currently boosted,
profiled, or matched by the default searches on DexScreener.

#### Holder data and `rpcUrl`

See *Holder analysis is an optional add-on* above. Only read methods are ever called on your RPC.

### Use it from Claude Desktop or Cursor (MCP)

Add the official Apify MCP server and expose just this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

In Cursor, put the same block in `.cursor/mcp.json`. Then ask: *"Run the token autopsy on these three CAs and
tell me which fail my rules."*

### A 7-step AI research workflow

This is a discipline, not a signal service. Each step maps to fields the Actor already returns.

1. **Pre-filter.** Run `trending_discovery` with your `minLiquidityUsd` and `minVolume1hUsd`. Drop every row
   whose `verdict` is `SKIP`. Most of the noise dies here.
2. **Autopsy.** For what remains, read `ruleChecks` and `redFlags` top-down. Any mint or freeze authority still
   live is disqualifying on its own.
3. **Narrative.** Ask the model to summarise `socials`, `name`, and age: is there a real community, or a
   ticker launched an hour ago with no links?
4. **Bundle check (with your RPC).** Look at `bundleSuspectScore` and `largestHolders`. Four wallets holding nearly identical
   percentages is the classic bundled-launch fingerprint.
5. **Dump simulation.** Read `graduationDumpSimulation`. If the top five holders selling would erase 80%+ of
   the price, that is your realistic exit, whatever the chart says.
6. **Sizing discipline.** Decide your own maximum loss *before* anything else. Nothing here sizes a position
   for you and nothing here should.
7. **Review.** Re-run the same mints later (Apify Schedules) and compare `verdict` and flags over time. Keep a
   log; the dataset already is one.

Example prompt: *"Here are 20 token autopsies as JSON. Group them by verdict, list the top red flag for each
SKIP, and for each WATCH tell me which single rule would need to change for it to pass. Do not give buy
advice."*

### Reliability

Three consecutive clean cloud runs with empty `{}` input (build 0.1.5, Apify Cloud, no RPC):

| Run ID | Started (UTC) | Rows | Errors | Charged events | Runtime |
|---|---|---|---|---|---|
| `fOzy2gI8mzDx7jpWi` | 2026-10-29 16:53:16 | 65 | 0 | 65 `token-autopsy` | 14.5s |
| `PSPm9MEsBig4OEnu2` | 2026-10-29 16:53:52 | 65 | 0 | 65 `token-autopsy` | 14.3s |
| `eXHjFfwbfmK7dez95` | 2026-10-29 16:54:11 | 65 | 0 | 65 `token-autopsy` | 14.8s |

Every run returned the same row count with zero entries in the `ERRORS` record. Example 1 below is the first row of run `eXHjFfwbfmK7dez95`.

### Real sample from a live run

First rows of an actual cloud `{}` run `eXHjFfwbfmK7dez95` (2026-10-29T16:54:14+00:00 UTC):

Verdicts in that run: **0 VALID_SETUP, 53 WATCH, 12 SKIP** out of 65 tokens (no RPC, so nothing can exceed WATCH or a 7.0 score).

| Symbol | DEX | Market cap | Liquidity | Age (h) | Confidence | Score | Raw | Verdict |
|---|---|---|---|---|---|---|---|---|
| PUMP | pumpswap | $2,114,531,163 | $24,010,740 | 11327.97 | limited | 7 | 9.8 | **WATCH** |
| AgenC | pumpswap | $981,156 | $84,744 | 0.53 | limited | 7 | 10 | **WATCH** |
| CBUCKS | pumpswap | $916,833 | $102,769 | 550.41 | limited | 7 | 10 | **WATCH** |
| SENSE | raydium | $1,174,289 | $136,357 | 2.28 | limited | 7 | 10 | **WATCH** |
| WDG | pumpfun | $3,831 | $0 | 144.11 | limited | 6.5 | 6.5 | **SKIP** |
| VI | pumpswap | $288,592 | $45,022 | 2.7 | limited | 7 | 10 | **WATCH** |
| STOMP | pumpfun | $12,355 | $0 | 6718.91 | limited | 6.5 | 6.5 | **SKIP** |
| STANK | raydium | $84,505 | $25,699 | 2.96 | limited | 7 | 10 | **WATCH** |

#### Example 1: real row from cloud run `eXHjFfwbfmK7dez95`, default `{}` input, no RPC

```json
{
  "mint": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "symbol": "PUMP",
  "name": "Pump",
  "dexId": "pumpswap",
  "pairAddress": "2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd",
  "pairUrl": "https://dexscreener.com/solana/2uf4xh61rdwxng9woyxsvqp7zua6klfpb3nvnrqeoisd",
  "discoverySource": "input",
  "priceUsd": 0.004592,
  "ageHours": 11327.97,
  "marketCapUsd": 2114531163,
  "liquidityUsd": 24010739.72,
  "liquidityToMcapPct": 1.14,
  "holderDataStatus": "skipped_no_rpc",
  "top10HoldersPct": null,
  "top1HolderPct": null,
  "largestHolders": [],
  "mintAuthorityRevoked": true,
  "freezeAuthorityRevoked": true,
  "bundleSuspectScore": null,
  "bundleDataStatus": "partial_no_rpc",
  "volume5mUsd": 13117.76,
  "volume1hUsd": 436949.66,
  "volume24hUsd": 5549009.31,
  "txns5mBuys": 52,
  "txns5mSells": 13,
  "txns1hBuys": 605,
  "txns1hSells": 302,
  "txns24hBuys": 15968,
  "txns24hSells": 8728,
  "buySellRatio1h": 2,
  "priceChange5mPct": 0.23,
  "priceChange1hPct": 1.62,
  "priceChange24hPct": 9.39,
  "socials": {
    "twitter": "https://x.com/pumpfun",
    "website": "https://pump.fun"
  },
  "ruleChecks": {
    "maxTop10HoldersPct": {
      "pass": null,
      "value": null,
      "limit": 25
    },
    "maxTop1HolderPct": {
      "pass": null,
      "value": null,
      "limit": 8
    },
    "minLiquidityUsd": {
      "pass": true,
      "value": 24010739.72,
      "limit": 5000
    },
    "minVolume1hUsd": {
      "pass": true,
      "value": 436949.66,
      "limit": 2500
    },
    "mintAuthorityRevoked": {
      "pass": true,
      "value": true,
      "limit": true
    },
    "freezeAuthorityRevoked": {
      "pass": true,
      "value": true,
      "limit": true
    },
    "minLiquidityToMcapPct": {
      "pass": false,
      "value": 1.14,
      "limit": 5
    },
    "maxBundleSuspectScore": {
      "pass": null,
      "value": null,
      "limit": 50
    }
  },
  "autopsyScore": 7,
  "rawScore": 9.8,
  "confidence": "limited",
  "verdict": "WATCH",
  "redFlags": [
    "Liquidity only 1.14% of market cap: thin exit",
    "holder check skipped, verify concentration before acting"
  ],
  "greenFlags": [
    "Mint authority revoked",
    "Freeze authority revoked",
    "Deep liquidity $24,010,740",
    "Net buying: 605 buys vs 302 sells (1h)",
    "Multiple socials listed",
    "Survived 472.0 days"
  ],
  "graduationDumpSimulation": {
    "model": "constant-product x*y=k on DexScreener pooled base (approximation)",
    "poolBaseTokens": 2617867765,
    "top5SellPriceImpactPct": null,
    "sell1PctSupply": 94.2,
    "sell5PctSupply": 99.64,
    "sell10PctSupply": 99.91
  },
  "claudePromptContext": "PUMP (pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn) on pumpswap: age 11327.97h, mcap $2,114,531,163, liq $24,010,740 (1.14% of mcap), 1h vol $436,950, 1h buys/sells 605/302, top10 holders not analysed (skipped_no_rpc), mint revoked True, freeze revoked True, bundle score not computed (partial_no_rpc), autopsy 7.0/10 (raw 9.8, limited confidence) -> WATCH. Red flags: Liquidity only 1.14% of market cap: thin exit; holder check skipped, verify concentration before acting. Analytical only, not financial advice.",
  "scrapedAt": "2026-10-29T16:54:14+00:00"
}
```

#### Example 2: holder-enabled row (ILLUSTRATIVE SHAPE ONLY)

> **Not real output.** This shows the field shape when `rpcUrl` is set. Holder numbers and account
> placeholders below are made up for illustration; only holder-related fields are shown; every other field matches Example 1.

```json
{
  "mint": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "symbol": "PUMP",
  "holderDataStatus": "ok",
  "bundleSuspectScore": 22,
  "bundleDataStatus": "ok",
  "confidence": "high",
  "top10HoldersPct": 18.42,
  "top1HolderPct": 4.1,
  "largestHolders": [
    {
      "rank": 1,
      "tokenAccount": "<pool vault token account>",
      "pct": 0.26,
      "isPoolVault": true
    },
    {
      "rank": 2,
      "tokenAccount": "<token account>",
      "pct": 4.1,
      "isPoolVault": false
    },
    {
      "rank": 3,
      "tokenAccount": "<token account>",
      "pct": 3.65,
      "isPoolVault": false
    }
  ],
  "ruleChecks": {
    "maxTop10HoldersPct": {
      "pass": true,
      "value": 18.42,
      "limit": 25.0
    },
    "maxTop1HolderPct": {
      "pass": true,
      "value": 4.1,
      "limit": 8.0
    },
    "minLiquidityUsd": {
      "pass": true,
      "value": 23982026.9,
      "limit": 5000.0
    },
    "minVolume1hUsd": {
      "pass": true,
      "value": 440982.3,
      "limit": 2500.0
    },
    "mintAuthorityRevoked": {
      "pass": true,
      "value": true,
      "limit": true
    },
    "freezeAuthorityRevoked": {
      "pass": true,
      "value": true,
      "limit": true
    },
    "minLiquidityToMcapPct": {
      "pass": false,
      "value": 1.14,
      "limit": 5
    },
    "maxBundleSuspectScore": {
      "pass": true,
      "value": 0,
      "limit": 50
    }
  },
  "graduationDumpSimulation": {
    "model": "constant-product x*y=k on DexScreener pooled base (approximation)",
    "poolBaseTokens": 2620674002.0,
    "top5SellPriceImpactPct": "<computed from top-5 balances>",
    "sell1PctSupply": 94.19,
    "sell5PctSupply": 99.64,
    "sell10PctSupply": 99.91
  },
  "claudePromptContext": "<same summary, with 'top10 holders 18.42%'>"
}
```

A typical `SKIP` from the same real run: **WDG**: Near-zero liquidity ($0); Liquidity only 0.0% of market cap: thin exit; holder check skipped, verify concentration before acting.

### API examples

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner").call(run_input={
    "mode": "mints_only",
    "mintAddresses": ["pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"],
    "maxTop10HoldersPct": 20,
})
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(t["symbol"], t["verdict"], t["autopsyScore"], t["redFlags"][:2])
```

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner').call({ mode: 'trending_discovery', dexFilter: ['pumpswap', 'pumpfun'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((t) => t.verdict !== 'SKIP').map((t) => t.claudePromptContext));
```

**cURL / JSON input**

```bash
curl -X POST "https://api.apify.com/v2/acts/informed_almandine_vzb~solana-pumpfun-token-autopsy-scanner/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"mints_only","mintAddresses":["https://pump.fun/coin/pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"]}'
```

### Pricing

Pay per event, **$0.00 start fee**.

| Event | Price |
|---|---|
| `token-autopsy` (one token analysed and saved) | **$0.0025** ($2.50 per 1,000) |

- A default `{}` run of ~65 tokens costs about **$0.16**.
- Scanning 60 trending tokens every hour for a day: 1,440 autopsies = **$3.60**.
- Apify's $5 monthly free credit covers about **2,000 autopsies**.
- Tokens with no Solana pair on DexScreener are logged in the `ERRORS` record and **not charged**.

### Limits and honest caveats

- DexScreener and RPC data are snapshots; meme-token markets move in seconds.
- `bundleSuspectScore` is only computed with your RPC; it is a heuristic from holder shape and flow, not a forensic trace of funding wallets.
- The dump simulation assumes a single constant-product pool and ignores other pools, fees, and arbitrage.
- Holder % uses the 20 largest token accounts; exchange or program accounts other than the pool vault are not
  labelled.

### Data, safety, and disclaimer

All data comes from public sources: the DexScreener public API and public Solana JSON-RPC read methods
(`getMultipleAccounts`, `getTokenLargestAccounts`). The Actor never asks for a seed phrase or private key,
never connects a wallet, and never sends a transaction. `VALID_SETUP`, `WATCH`, and `SKIP` describe how a token
scores against the rules you set; they are **not** recommendations to buy, sell, or hold. Crypto tokens,
especially new Pump.fun launches, can and do go to zero. Do your own research.

# Actor input Schema

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

'autopsy_and_trending' autopsies your mints plus trending/boosted Solana tokens; 'mints_only' only your list; 'trending_discovery' only DexScreener boosts, profiles and search results.

## `mintAddresses` (type: `array`):

Solana token mint addresses (CAs), DexScreener pair/token URLs, or pump.fun/coin URLs.

## `searchQueries` (type: `array`):

Free-text DexScreener searches used to discover more Solana pairs (non-Solana results are dropped).

## `dexFilter` (type: `array`):

Keep only these DexScreener dexIds (e.g. pumpfun, pumpswap, raydium, meteora, orca). Empty = all.

## `maxTop10HoldersPct` (type: `number`):

Rule: top 10 wallets (excluding the pool vault) may hold at most this % of supply.

## `maxTop1HolderPct` (type: `number`):

Rule: the largest non-pool wallet may hold at most this % of supply.

## `minLiquidityUsd` (type: `number`):

Rule: minimum pooled liquidity in USD.

## `minVolume1hUsd` (type: `number`):

Rule: minimum 1-hour trading volume in USD.

## `rpcUrl` (type: `string`):

Optional add-on. Paste your own read-only Solana RPC URL to enable top-10/top-1 holder analysis, pool-vault exclusion and the holder rules. Empty = holder lookup skipped (holderDataStatus: skipped_no_rpc). No extra charge.

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

Maximum tokens to autopsy (each is one billed token-autopsy event).

## `delaySeconds` (type: `number`):

Polite pause between requests.

## Actor input object example

```json
{
  "mode": "autopsy_and_trending",
  "mintAddresses": [
    "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
  ],
  "searchQueries": [
    "pump",
    "pumpswap",
    "raydium",
    "solana meme",
    "ai agent sol"
  ],
  "dexFilter": [],
  "maxTop10HoldersPct": 25,
  "maxTop1HolderPct": 8,
  "minLiquidityUsd": 5000,
  "minVolume1hUsd": 2500,
  "rpcUrl": "",
  "maxItems": 65,
  "delaySeconds": 0.25
}
```

# Actor output Schema

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

No description

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

No description

# 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": "autopsy_and_trending",
    "mintAddresses": [
        "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
    ],
    "searchQueries": [
        "pump",
        "pumpswap",
        "raydium",
        "solana meme",
        "ai agent sol"
    ],
    "dexFilter": [],
    "maxTop10HoldersPct": 25,
    "maxTop1HolderPct": 8,
    "minLiquidityUsd": 5000,
    "minVolume1hUsd": 2500,
    "rpcUrl": "",
    "maxItems": 65
};

// Run the Actor and wait for it to finish
const run = await client.actor("informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner").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": "autopsy_and_trending",
    "mintAddresses": ["pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"],
    "searchQueries": [
        "pump",
        "pumpswap",
        "raydium",
        "solana meme",
        "ai agent sol",
    ],
    "dexFilter": [],
    "maxTop10HoldersPct": 25,
    "maxTop1HolderPct": 8,
    "minLiquidityUsd": 5000,
    "minVolume1hUsd": 2500,
    "rpcUrl": "",
    "maxItems": 65,
}

# Run the Actor and wait for it to finish
run = client.actor("informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner").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": "autopsy_and_trending",
  "mintAddresses": [
    "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
  ],
  "searchQueries": [
    "pump",
    "pumpswap",
    "raydium",
    "solana meme",
    "ai agent sol"
  ],
  "dexFilter": [],
  "maxTop10HoldersPct": 25,
  "maxTop1HolderPct": 8,
  "minLiquidityUsd": 5000,
  "minVolume1hUsd": 2500,
  "rpcUrl": "",
  "maxItems": 65
}' |
apify call informed_almandine_vzb/solana-pumpfun-token-autopsy-scanner --silent --output-dataset

```

## MCP server setup

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

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/fd4Yqnw8ix93tlzes/builds/2FqGsD2Po0c1XZb5t/openapi.json