# Memecoin Alpha Caller Leaderboard - Pump.fun KOL Track Records (`intenal_builds/memecoin-caller-track-record`) Actor

Leaderboard of pump.fun memecoin callers (KOLs) on Solana ranked by measured hit rate, median return, consistency score and recency trend, plus per-call outcomes at t+5m, t+30m and t+4h. Historical archive, derived only from recorded data.

- **URL**: https://apify.com/intenal_builds/memecoin-caller-track-record.md
- **Developed by:** [Jaydan Eaton](https://apify.com/intenal_builds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 callers

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

## Memecoin Alpha Caller Leaderboard: Pump.fun KOL Track Records (Solana)

Who actually calls pump.fun memecoins *before* they run? This actor ranks **Solana memecoin callers (KOLs)** by their **measured** results: what happened to each token **5 minutes, 30 minutes and 4 hours** after the call. You get hit rates, median returns, a sample-size-aware consistency score, a recency trend, and each caller's best and worst call.

### What you get

- **Caller leaderboard**, one row per caller: calls, unique tokens, hit rate / median peak multiple / median return / mean return / above-call rate for **t+5m, t+30m and t+4h**, a **consistency score** (Wilson 95% lower bound of the 4h hit rate, so a 1-for-1 caller can't beat a proven caller), a **recency trend** (later half vs earlier half), best call, worst call, median entry market cap, and cross-reference with our pump.fun graduated-token corpus.
- **Per-call records**: pump.fun callout id, call time, public caller handle and linked X handle, ticker, token mint, market cap and price at call, market cap / return / peak multiple at each window, snapshot status, graduation info.
- Full ranked leaderboard JSON is also saved to the key-value store (`LEADERBOARD`).

### Example output (actual first rows from a default run: minCalls 2, sorted by consistency)

| rank | caller | calls | hit rate 4h (2x) | median return 4h | consistency | skin in game | wallet finder signals |
|---|---|---|---|---|---|---|---|
| 1 | Cryp3po | 2 | 1.0 | 0.645 | 0.3424 | 1.0 | callout_2x_hitter, pumpfun_caller |
| 2 | Mzgete\_ | 2 | 0.5 | 0.6994 | 0.0945 | 1.0 | callout_2x_hitter, pumpfun_caller |
| 3 | ferre | 2 | 0.5 | 0.3157 | 0.0945 | 1.0 | callout_2x_hitter, pumpfun_caller |
| 4 | Trulli | 2 | 0.5 | 0.9988 | 0.0945 | 1.0 | callout_2x_hitter, pumpfun_caller |
| 5 | XTK | 2 | 0.5 | 0.219 | 0.0945 | 1.0 | callout_2x_hitter, pumpfun_caller |

Return values are multiples of the call price (0.61 means the token was at 61% of the call price after 4h). Consistency is the Wilson lower bound, which is why it stays low at these sample sizes.

### New in v0.2

- **Caller skin-in-the-game** (from pump.fun's own callout records, no RPC needed): `skinInGameRate`, `medianCallerHoldingsUsdAtCall`, `medianCallerAmountBoughtUsd`, and per call `callerHoldingsPctSupplyAtCall`.
- **Public caller wallets + cross-link to the Solana Smart Money Wallet Finder:** each caller row has `walletFinderLink` with the wallet(s), their Wallet Finder signals and a ready-made `lookupInput` for that Actor.
- `graduatedTokenCallRate`, `activeSpanDays`, and a `sampleSizeWarning` on every caller.
- A `SAMPLE_SIZE` record in the key-value store with the exact coverage of your run.

### Filters

Caller handles (pump.fun or X), minimum calls, date range, hit multiple (default 2x), sort by hit rate, median return, consistency, median peak or number of calls.

### Data and coverage (please read)

- **Honest sample size: this is a small archive.** It has 882 pump.fun callouts by 828 callers, 2026-09-25 to 2026-10-03 (UTC):

  | calls per caller | callers |
  |---|---|
  | 1 | 785 |
  | 2 | 35 |
  | 3 | 5 |
  | 4 | 3 |
  | 5 or more | 0 |

  No caller has 5 or more calls, so every leaderboard rank comes from a handful of calls and is **anecdotal, not statistically meaningful**. Use it to screen and cross-check callers, not to judge them. The per-call outcomes (882 measured) are the more solid part of the data. There is **no live refresh**. Measuring the 4h outcome of a new call means waiting 4 hours, which doesn't fit inside one cheap run.
- Market cap / price at call are what pump.fun recorded on the callout. Forward values are snapshots from DexScreener / pump.fun; peaks come from 1-minute candle highs. A peak taken from the call-minute candle can include trades from just before the call.
- **Only public data:** caller handles, token mints, and the caller wallets and holdings that pump.fun shows publicly on each callout. No private data.
- Every number is computed from these records. Nothing is estimated or made up.

### Example input

```json
{ "outputType": "leaderboard", "minCalls": 2, "sortBy": "consistency", "hitMultiple": 2 }
```

### Pricing

Pay per event: you're charged for each record output (`caller` row or `call` row). Runs stop at your spend limit.

### Disclaimer

**Not financial advice.** This data describes the past. It promises no returns and doesn't predict how any caller or token will do. Memecoins are extremely risky. This actor is **not affiliated with, endorsed by or sponsored by pump.fun, X, DexScreener or any caller**.

Keywords: pump.fun, memecoin, Solana, KOL callers, alpha callers, crypto influencer track record, smart money, callout leaderboard.

### More from Intenal_Builds

- [Pump.fun Graduated Tokens Dataset](https://apify.com/intenal_builds/pumpfun-graduated-tokens-dataset) - every pump.fun graduation on Solana with market-cap path
- [Crypto Launch Radar](https://apify.com/intenal_builds/crypto-launch-radar) - new tokens and pairs from DEX Screener and GeckoTerminal
- [AI Trend Radar](https://apify.com/intenal_builds/ai-trend-radar) - trending Hugging Face, GitHub and arXiv AI projects

# Actor input Schema

## `outputType` (type: `string`):

What to output: caller leaderboard rows, individual call records, or both.

## `callerHandles` (type: `array`):

Only include these callers (pump.fun handle or X handle, case-insensitive, @ optional). Empty = all callers.

## `minCalls` (type: `integer`):

Only rank callers with at least this many calls in the selected date range.

## `startDate` (type: `string`):

Only include calls on/after this date (YYYY-MM-DD or ISO timestamp, UTC).

## `endDate` (type: `string`):

Only include calls on/before this date (YYYY-MM-DD or ISO timestamp, UTC).

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

Leaderboard sort key (all based on the t+4h window).

## `hitMultiple` (type: `number`):

A call counts as a hit when the peak price within the window reached this multiple of the call price (e.g. 2 = 2x).

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

Maximum records to output (each record is one billable event).

## Actor input object example

```json
{
  "outputType": "leaderboard",
  "callerHandles": [],
  "minCalls": 2,
  "sortBy": "consistency",
  "hitMultiple": 2,
  "maxResults": 100
}
```

# Actor output Schema

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

Leaderboard rows and/or call records.

## `leaderboard` (type: `string`):

Full ranked leaderboard (not charged) in the key-value store.

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

// Run the Actor and wait for it to finish
const run = await client.actor("intenal_builds/memecoin-caller-track-record").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 = { "callerHandles": [] }

# Run the Actor and wait for it to finish
run = client.actor("intenal_builds/memecoin-caller-track-record").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 '{
  "callerHandles": []
}' |
apify call intenal_builds/memecoin-caller-track-record --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,intenal_builds/memecoin-caller-track-record"
        }
    }
}
```

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/dVryKcPndLhECcQfv/builds/1ELSbwIgTt7ocf2bU/openapi.json