# Pump.fun Bundle & Insider Checker - Solana Holder Trace (`centorprat/solana-token-holder-trace`) Actor

Who really bought a pump.fun token? Traces the earliest buyers from the launch: snipers, bundles, wallets funded by one wallet or the dev, fresh and bot wallets, supply still held. Coordination risk %, verdict, summary. Max tier: 60 buyers, 2 hops, creator's other launches.

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

## Pricing

from $42.50 / 1,000 token traced (standard)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Pump.fun Bundle & Insider Checker — Solana Holder Trace

Who really bought this pump.fun token? Give token mints and each one gets a **holder trace**: the **earliest buyers** read from the token's own launch on-chain, **snipers** (bought within 2 slots of creation), **bundled buys** (same slot as creation), **groups of wallets funded by the same wallet**, wallets **funded by or with the dev**, **fresh wallets** created right before launch, **bot-like wallets**, and how much of the supply those connected wallets **bought and still hold right now**. You get one **coordination risk %**, a plain verdict and a one-paragraph summary.

> **Signals for due diligence, not financial advice.** "Mostly independent buyers" is not a guarantee. A token can still dump for reasons this trace can't see.

### What you get per token

- **Launch structure:** the creator, the dev's initial buy, snipers and their supply share, same-slot bundles, and whether the token has graduated from the bonding curve (plus market cap and curve progress while it's still on the curve).
- **Funding trace:** each early buyer's **first SOL funding**, which tells you who created that wallet.
  - Wallets that share a funder are grouped into clusters: one operator, many wallets.
  - Exchange hot wallets and other hubs (1000+ transactions) are listed apart and **never** counted as one operator, so a Binance withdrawal doesn't look like an insider ring.
- **Dev links:** buyers funded by the creator, or by the creator's own funder.
- **Fresh and bot-like wallets:** wallets created less than 24 h before launch, and high-frequency wallets (snipers and bots).
- **Connected supply:** the % of supply the connected wallets bought, and the % they **hold now** (balances read live).
- **`coordinationRiskPct`** (0–100) and a **verdict**:
  - `mostly independent buyers`
  - `partly coordinated`
  - `coordinated`
  - `coordinated launch: connected wallets took X% of supply, now hold Y% (mostly sold)`
- A per-wallet table: funder, first buy slot after launch, bought %, holds %, and sniper / bundled / fresh / dev-linked / bot-like flags.

### Two tiers: standard and max

| | standard | max |
|---|---|---|
| Early buyers traced | 30 | 60 |
| Funding hops | 1 (who funded the buyer) | 2 (who funded the funder) |
| Launch history scanned | up to 12,000 curve transactions | up to 40,000 |
| Creator's other recent launches (serial launcher check) | — | ✅ |
| Price per token | standard event | max event |

Invalid addresses and tokens that aren't pump.fun are free.

### Why not just ask an AI agent?

An agent sees the token page, not the funding graph. Here's what this does for you:

- reads the token's launch transactions from the chain;
- decodes pump.fun's trade events;
- follows every early buyer back to the wallet that funded it;
- filters out exchange hubs;
- reads current balances;
- turns all of it into one scored answer.

It usually takes 300–600 RPC calls, and the actor does it per token in about a minute.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `tokens` | array of strings | ✅ | pump.fun token mints (up to 50 per run) |
| `tier` | string | | `standard` (default) or `max` |
| `rpcUrl` | string | | your own Solana RPC (Helius, QuickNode, Triton…). Faster; stored as a secret |
| `rpcRequestsPerSecond` | integer | | your RPC plan's rate limit (default 25) |
| `webhookUrl` | string | | POST all traces here when the run finishes |

```json
{ "tokens": ["4artD1xPXaEiqocuZxAxmibLBLkvrpKmUZnBEmueUX5k"], "tier": "standard" }
```

### Output (one item per token)

```json
{
  "token": "4artD1xP...UX5k", "symbol": "TRUMP", "tier": "standard", "found": true,
  "verdict": "mostly independent buyers", "coordinationRiskPct": 4,
  "snipers": 3, "sniperBoughtPct": 1.01, "bundledBuyers": 0,
  "clusters": [], "devLinkedWallets": [], "freshWalletPct": 3.3, "botLikeWalletPct": 76.7,
  "connectedBoughtPct": 0.0, "connectedHoldsPct": 0.0, "devHoldsPct": 0.0, "graduated": true,
  "summary": "TRUMP: mostly independent buyers (coordination risk 4%). 30 early buyers traced: 3 sniped within 2 slots ...",
  "buyers": [{"wallet": "...", "funder": "...", "boughtPct": 1.2, "holdsPct": 0.0, "sniper": true, "botLike": true}]
}
```

### Notes

- Works for pump.fun tokens, both on the bonding curve and graduated. For a very busy token (more launch transactions than the tier scans), `launchReached` is `false` and the earliest reachable buyers are traced instead.
- A wallet's first funding can only be found cheaply for wallets with fewer than 1000 transactions. Busier wallets are reported as `botLike`.
- Uses public Solana RPC endpoints by default (paced to their limits). Add your own `rpcUrl` for speed.

# Actor input Schema

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

pump.fun token mint addresses (the address ending in 'pump' on most launches). One trace per token, up to 50 per run.

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

standard: 30 earliest buyers, 1 funding hop. max: 60 earliest buyers, 2 funding hops (the funder's funder), deeper launch history, the creator's other recent launches (serial launcher check) and the full per-wallet table. Max is charged at the max price.

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

Optional: your own Solana RPC endpoint (Helius, QuickNode, Triton...). Faster and more reliable than the public endpoints used by default. Stored as a secret.

## `rpcRequestsPerSecond` (type: `integer`):

Only with your own RPC URL: how many requests per second your plan allows (default 25).

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

If set, all traces are POSTed here as JSON when the run finishes.

## Actor input object example

```json
{
  "tokens": [
    "4artD1xPXaEiqocuZxAxmibLBLkvrpKmUZnBEmueUX5k"
  ],
  "tier": "standard",
  "rpcRequestsPerSecond": 25
}
```

# Actor output Schema

## `traces` (type: `string`):

One trace per token: coordination risk %, verdict, clusters of wallets sharing a funder, dev-linked wallets, snipers, bundles, fresh and bot-like wallets, supply bought and held now, per-wallet table and a plain summary.

# 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 = {
    "tokens": [
        "4artD1xPXaEiqocuZxAxmibLBLkvrpKmUZnBEmueUX5k"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/solana-token-holder-trace").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 = { "tokens": ["4artD1xPXaEiqocuZxAxmibLBLkvrpKmUZnBEmueUX5k"] }

# Run the Actor and wait for it to finish
run = client.actor("centorprat/solana-token-holder-trace").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 '{
  "tokens": [
    "4artD1xPXaEiqocuZxAxmibLBLkvrpKmUZnBEmueUX5k"
  ]
}' |
apify call centorprat/solana-token-holder-trace --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/solana-token-holder-trace"
        }
    }
}
```

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/2HBzhcBbFbWAB1Prr/builds/ig5YZUBg2JhS7cIRH/openapi.json