# Memecoin Launch Detector - Solana & Base New Token Pairs (`gochujang/memecoin-launch-detector`) Actor

Detect and track new memecoin launches on Solana and Base using DexScreener. Monitor price, liquidity, volume, rug risk score, and momentum labels. No API key required.

- **URL**: https://apify.com/gochujang/memecoin-launch-detector.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 token trackeds

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

### What does Memecoin Launch Detector do?

**Memecoin Launch Detector** is a real-time **new memecoin tracker** for Solana and Base — surfacing freshly launched token pairs from DexScreener with 8 advanced analytics signals including launch quality score, rug pull risk, pump phase, holder distribution quality, liquidity health, social momentum, estimated peak proximity, and memecoin archetype. No API key or proxy needed. This **memecoin launch detector** is built for traders who need structured data, not raw token lists, to make faster decisions on **pump.fun token alerts** and new launches.

### Why use Memecoin Launch Detector?

- **Early entry sniping** — detect tokens in the `pre_launch` or `just_launched` pump phase before the crowd, filtered by minimum liquidity and quality score
- **Rug pull filtering** — use `rug_pull_risk` and `liquidity_health_score` to automatically exclude high-risk launches and focus on safer entries with this **new memecoin tracker**
- **pump.fun token alert automation** — filter to `is_pump_fun: true` and `social_momentum_signal: "viral"` to track only pump.fun graduation candidates with the highest viral potential
- **Telegram / Discord alert bots** — feed viral launches directly into community notification pipelines triggered by `social_momentum_signal`
- **Market heat monitoring** — the `memecoin_market_heat` signal tells you whether the market is boiling, hot, warm, or dead — useful for macro memecoin cycle timing

### How to use Memecoin Launch Detector

1. Open the **Memecoin Launch Detector** actor on Apify Store
2. Click **Try for free** — no API key required
3. Set `chains` to `["solana"]`, `["base"]`, or both (default: both)
4. Configure filters: `min_liquidity_usd` (e.g. `10000`), `max_age_hours` (e.g. `6`), `include_pump_fun_only` for pump.fun only
5. Set `max_results` to limit output size
6. Click **Run** — results appear in seconds with full analytics per token
7. Read the `market_summary` from the Key-Value Store for the top 5 by quality, safety, and virality

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `chains` | string\[] | `["solana","base"]` | Chains to scan for new token pairs |
| `min_liquidity_usd` | number | `5000` | Minimum pool liquidity in USD |
| `max_age_hours` | number | `24` | Maximum token age in hours |
| `min_volume_24h` | number | `0` | Minimum 24-hour volume in USD |
| `include_pump_fun_only` | boolean | `false` | Filter to pump.fun launches only |
| `max_results` | integer | `100` | Max tokens returned (0 = unlimited) |
| `include_market_summary` | boolean | `true` | Save market summary to Key-Value Store and dataset |

### Output

One record per token pushed to the dataset, plus a `market_summary` record saved to the Key-Value Store.

```json
[
  {
    "token_name": "DOGE2",
    "token_symbol": "DOGE2",
    "chain": "solana",
    "contract_address": "7xKp...mNq2",
    "dex_id": "raydium",
    "created_at": "2026-09-02T08:31:00Z",
    "age_hours": 1.5,
    "price_usd": 0.000042,
    "liquidity_usd": 28400,
    "fdv_usd": 420000,
    "volume_24h": 185000,
    "buy_sell_ratio": 2.1,
    "momentum_label": "pumping",
    "is_pump_fun": true,
    "launch_quality_score": 61,
    "rug_pull_risk": "moderate",
    "pump_phase": "early_pump",
    "holder_distribution_quality": "moderate",
    "liquidity_health_score": 54,
    "social_momentum_signal": "growing",
    "estimated_peak_proximity": "pre_peak",
    "memecoin_archetype": "animal_coin",
    "dexscreener_url": "https://dexscreener.com/solana/7xKp...mNq2"
  }
]
```

### Data fields

#### Core market data

| Field | Description |
|---|---|
| `token_name` / `token_symbol` | Token name and ticker |
| `chain` | `solana` or `base` |
| `contract_address` | Token contract / mint address |
| `pair_address` | DEX pair address |
| `dex_id` | DEX platform (e.g. `raydium`, `pumpfun`, `uniswap`) |
| `age_hours` | Hours since pair creation |
| `price_usd` | Current token price in USD |
| `liquidity_usd` | Total pool liquidity in USD |
| `fdv_usd` | Fully diluted valuation in USD |
| `volume_24h` | 24-hour trading volume in USD |
| `volume_1h` | 1-hour trading volume in USD |
| `price_change_1h_pct` | % price change in last 1 hour |
| `buy_sell_ratio` | buys_24h ÷ sells_24h (>1 = more buying pressure) |
| `momentum_label` | `mooning` / `pumping` / `stable` / `dumping` / `rugging` |
| `is_pump_fun` | `true` if launched via pump.fun |
| `fdv_to_liquidity_ratio` | FDV ÷ liquidity (>100× = elevated risk) |
| `dexscreener_url` | Direct link to DexScreener pair page |

#### Advanced analytics

| Field | Values | Description |
|---|---|---|
| `launch_quality_score` | 0–100 | Composite: liquidity depth (30pts) + holder distribution (25pts) + contract safety (25pts) + social traction (20pts) |
| `rug_pull_risk` | extreme / high / moderate / low / minimal | Categorical **rug pull risk** assessment |
| `pump_phase` | pre_launch / just_launched / early_pump / peak / cooling / dead / survived | Current phase in the **pump.fun token** lifecycle |
| `holder_distribution_quality` | whale_dominated / concentrated / moderate / healthy / decentralized | Approximated holder spread from tx diversity and FDV/liquidity ratio |
| `liquidity_health_score` | 0–100 | Liquidity/mcap ratio + LP stability proxy + transaction diversity |
| `social_momentum_signal` | viral / trending / growing / flat / fading | Estimated social traction from volume acceleration and link count |
| `estimated_peak_proximity` | pre_peak / at_peak / post_peak / unclear | Position in the pump cycle |
| `memecoin_archetype` | animal_coin / ai_themed / political / pop_culture / food / based_meme / meta_game / other | Token theme classified from name and symbol keywords |

**Rug risk score factors (legacy `rug_risk_score` field):**

| Factor | Points |
|---|---|
| Liquidity below $5,000 | +30 |
| FDV/liquidity ratio > 1000× | +25 |
| Liquidity $5K–$20K | +15 |
| FDV/liquidity ratio > 100× | +15 |
| Token age under 1 hour | +15 |
| Token age under 6 hours | +8 |
| No social links or website | +10 |
| Fewer than 20 transactions in 24h | +10 |
| Zero 24h volume | +10 |

### Cost estimation

| Usage | Cost |
|---|---|
| Flat run fee | $0.001 per run |
| Per token tracked | $0.002 per token |
| 100 tokens per run | $0.21 per run |
| Hourly scans of 50 tokens | ~$7.50/month |
| Daily scan of 100 tokens | ~$6.30/month |

**Pricing model:** $0.001 flat + $0.002 per token (Pay-Per-Event). No API key costs.

### FAQ

**How fast does this memecoin launch detector find new tokens?**
The actor queries the DexScreener public API which updates in near-real-time. By setting `max_age_hours` to `1` and scheduling runs every 15 minutes, you can catch tokens within minutes of their first liquidity pool creation — well before most **new memecoin tracker** services surface them.

**What is the difference between `rug_pull_risk` and `launch_quality_score`?**
`rug_pull_risk` measures downside danger (low liquidity, no social links, high FDV/liquidity ratio). `launch_quality_score` measures upside potential (liquidity depth, holder distribution, social traction). A token can have low rug risk but also low quality — use both for complete filtering.

**Does this pump.fun token alert tracker work for non-pump.fun tokens?**
Yes. The actor scans all new token pairs on DexScreener for the selected chains, regardless of launchpad. Set `include_pump_fun_only: true` to restrict to pump.fun launches only, or leave it `false` (default) to track all new pairs including Raydium direct launches and Uniswap on Base.

***

> **Disclaimer:** Memecoin Launch Detector provides real-time market data from the DexScreener public API for informational and research purposes only. Memecoin trading carries extreme risk of total loss. Rug pull risk scores and quality signals are heuristic estimates — they do not guarantee outcomes. This is not financial advice. Never invest more than you can afford to lose.

***

### Related actors

- [DEX New Token Scanner](https://apify.com/gochujang/dex-new-token-scanner) — Multi-chain new token launches including memecoins across Base and Ethereum
- [DexScreener Token Screener](https://apify.com/gochujang/dexscreener-token-screener) — Filter new launches from this actor using custom volume, liquidity, and age criteria
- [Solana Memecoin Launch Tracker](https://apify.com/gochujang/solana-memecoin-launch-tracker) — Dedicated pump.fun Solana launch data to complement this actor's multi-chain feed

### Feedback

If this actor powers your memecoin research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/memecoin-launch-detector#reviews)

***

**Keywords:** memecoin launch detector, new token launches Solana, Base new token pairs, DexScreener new pairs, pump.fun graduation tracker, bonding curve monitor, early buy volume detector, top holder concentration, Solana memecoin tracker, new crypto launches, token liquidity add alert, DeFi new token scanner, memecoin early entry, rug pull detection

# Actor input Schema

## `chains` (type: `array`):

Which chains to scan for new token launches.

## `min_liquidity_usd` (type: `integer`):

Minimum pool liquidity in USD to include a token. Filters out extremely illiquid pairs.

## `max_age_hours` (type: `integer`):

Only return tokens created within this many hours ago.

## `min_volume_24h` (type: `integer`):

Minimum 24h trading volume in USD. Set to 0 to include all.

## `include_pump_fun_only` (type: `boolean`):

If enabled, only return tokens launched via pump.fun (Solana).

## `max_results` (type: `integer`):

Maximum number of tokens to return per chain. Set to 0 for unlimited.

## `include_market_summary` (type: `boolean`):

If enabled, appends a market summary record to the dataset and saves it to Key-Value Store (market_summary key). Includes newly_launched_count, highest_quality_launches, safest_to_ape, viral_right_now, and memecoin_market_heat.

## `alertMinVolume` (type: `number`):

Send Telegram alert only for memecoins with 24h volume above this threshold.

## `telegramBotToken` (type: `string`):

Telegram bot token for sending alerts (e.g. 123456:ABC-DEF...).

## `telegramChatId` (type: `string`):

Telegram chat ID to send alerts to (e.g. -1001234567890 or 987654321).

## Actor input object example

```json
{
  "chains": [
    "solana",
    "base"
  ],
  "min_liquidity_usd": 5000,
  "max_age_hours": 24,
  "min_volume_24h": 0,
  "include_pump_fun_only": false,
  "max_results": 100,
  "include_market_summary": true,
  "alertMinVolume": 50000
}
```

# Actor output Schema

## `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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/memecoin-launch-detector").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("gochujang/memecoin-launch-detector").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 gochujang/memecoin-launch-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/memecoin-launch-detector"
        }
    }
}
```

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/9CzXabj3ogQthn6Qj/builds/rXgQ10LsU33ayDWGe/openapi.json