# Meme Coin Intelligence & Early Momentum Scanner (`tuhin/meme-coin-momentum-scanner`) Actor

Detect meme coins gaining momentum before the crowd. On-chain market intelligence across Solana, Ethereum, Base & BNB: early-momentum, volume-before-price, under-the-radar, FOMO warnings, narrative detection, risk indicators and an explainable Opportunity Score.

- **URL**: https://apify.com/tuhin/meme-coin-momentum-scanner.md
- **Developed by:** [Tuhin](https://apify.com/tuhin) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Meme Coin Intelligence & Early Momentum Scanner 🚀

**Detect meme coins gaining momentum before the crowd notices.** An explainable on-chain intelligence engine that ranks tokens by *early momentum, volume-before-price, under-the-radar potential, FOMO risk, narrative and risk* — with the actual metrics behind every score.

> **Analytical indicators only — not financial advice.** Meme coins are extremely high-risk.

### 🧠 What it does

For every token it computes explainable 0–100 scores:

- **Opportunity Score** — weighted overall signal
- **Early Momentum** — volume/transaction acceleration before price moves
- **Volume-Before-Price** — trading rising while price is still flat
- **Under-the-Radar** — meaningful activity at still-low market cap
- **FOMO Risk** — overheating / blow-off warning
- **Whale trade-flow** *(proxy)* — large average trade size + buy pressure
- **Hype Authenticity** *(proxy)* — trade-flow balance
- **Risk** — liquidity, age, buy/sell imbalance, low-float indicators

Plus **lifecycle stage** (new / early-momentum / accelerating / viral / overheated / declining / dormant), **narrative** (AI, Dogs, Cats, Frogs, Politics, Gaming…), and a plain-English **"why trending"** built from real metrics.

### 🔌 Data & honest scope

- **v1 uses DexScreener** (public, no key): price, multi-timeframe volume & price change (5m/1h/6h/24h), liquidity, buys/sells, market cap, FDV, token age, trending boosts. This powers all the engines above.
- **Modular stubs for v2** (need API keys you supply): wallet-level **whale/holder** clustering (Helius/Birdeye) and **social velocity** (X/Reddit/TikTok/Telegram). Those score fields are returned as `null` until keys are added — the architecture already has the slots.

### ⚙️ Input

| Field | Description |
|-------|-------------|
| `mode` | `full` / `market` / `momentum` / `under_the_radar` / `narrative` / `risk`. |
| `chains` | `solana`, `ethereum`, `base`, `bsc`… (empty = all). |
| `seedQueries` | Extra DexScreener search terms to widen discovery. |
| `minLiquidityUsd` / `minVolumeH24` / `maxMarketCapUsd` / `maxAgeHours` | Cheap pre-filters. |
| `minOpportunityScore` / `maxTokens` | Output controls. |
| `previousDatasetId` | Prior run → cross-run deltas + change alerts. |

#### Example

```json
{ "mode": "under_the_radar", "chains": ["solana","base"], "minLiquidityUsd": 15000, "maxMarketCapUsd": 3000000 }
```

### 📦 Outputs

- **Tokens** (default dataset) — one row per token: address, chain, name, symbol, price, market cap, liquidity, volumes, price changes, buys/sells, all scores, lifecycle, narrative, `whyTrending`, `scoreComponents` (evidence), URLs.
- **`evidence`** dataset — token, signal type, metric, previous vs current value, source URL.
- **`narratives`** dataset — narrative, token count, avg scores, total volume, momentum status, top tokens.
- **`alerts`** dataset — opportunity>85, volume spike, whale accumulation, FOMO warning, volume breakout, risk high.
- Run summary in key-value store `OUTPUT`.

### 📅 Scheduling & history

Schedule it and pass `previousDatasetId` to unlock cross-run momentum: volume/price/market-cap deltas and breakout alerts. History is never fabricated — deltas appear only when a baseline exists.

### 🧮 Scoring methodology (transparent)

Every score is a documented formula over public metrics (e.g. Early Momentum = volume-acceleration + buy-pressure + recency). The exact inputs are stored per token in `scoreComponents`, so you can always see *why* a token ranked where it did.

### 🔑 Keywords

meme coin scanner, solana meme coins, early momentum, crypto gem finder, volume before price, dexscreener scanner, memecoin intelligence, low cap gems, narrative rotation, on-chain momentum.

### ⚠️ Disclaimer

Signals are analytical indicators from public market data, **not** guaranteed trading signals or financial advice. Whale/social scores are proxies or pending API keys. Do your own research.

# Actor input Schema

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

Market Scanner (broad), Early Momentum, Under the Radar, Narrative, Risk, or Full Intelligence (all signals).

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

Chains to scan, e.g. "solana", "ethereum", "base", "bsc". Empty = all.

## `seedQueries` (type: `array`):

Optional DexScreener search terms to widen discovery beyond trending (e.g. "pepe", "ai", "cat").

## `minLiquidityUsd` (type: `integer`):

Filter out illiquid/dust pairs.

## `minVolumeH24` (type: `integer`):

Minimum 24h volume.

## `maxMarketCapUsd` (type: `integer`):

Cap to keep it 'meme'/early. 0 = no cap.

## `maxAgeHours` (type: `integer`):

Only tokens younger than this. 0 = no limit.

## `minOpportunityScore` (type: `integer`):

Only output tokens at/above this Opportunity Score.

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

Maximum tokens in the output.

## `previousDatasetId` (type: `string`):

Dataset ID of a previous run — enables cross-run deltas (volume-before-price, holder/price change over time) and change alerts.

## `proxyConfiguration` (type: `object`):

Optional. DexScreener works without a proxy.

## Actor input object example

```json
{
  "mode": "full",
  "chains": [
    "solana",
    "base"
  ],
  "minLiquidityUsd": 8000,
  "minVolumeH24": 15000,
  "maxMarketCapUsd": 0,
  "maxAgeHours": 0,
  "minOpportunityScore": 0,
  "maxTokens": 80,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `tokens` (type: `string`):

One row per token with all scores + evidence. Also written: named datasets 'evidence', 'narratives', 'alerts'; run summary in key-value store OUTPUT.

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

// Run the Actor and wait for it to finish
const run = await client.actor("tuhin/meme-coin-momentum-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 = { "chains": ["solana"] }

# Run the Actor and wait for it to finish
run = client.actor("tuhin/meme-coin-momentum-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 '{
  "chains": [
    "solana"
  ]
}' |
apify call tuhin/meme-coin-momentum-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tuhin/meme-coin-momentum-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/pBsCnEEYwyffuKVzc/builds/C5KnGdqwv4EOCNO0G/openapi.json