# New Token Momentum Scanner - Early DEX Launches & Risk (`centorprat/new-token-momentum-scanner`) Actor

Scans newly-created DEX pools across chains (keyless) and ranks them by observable early-momentum signals - liquidity, volume acceleration, buy/sell pressure, unique buyers, FDV/liquidity - with risk/rug flags and a 0-100 momentum + risk score. Signals, not predictions. Read-only, agent-callable.

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

## Pricing

from $17.00 / 1,000 scan runs

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

## New Token Momentum Scanner — Early DEX Launches & Risk

Surface and rank **just-created** tokens across chains before they're on anyone's radar. The scanner pulls newly-created liquidity pools from multiple DEXes (keyless) and scores each on the observable **early-momentum** signals a person can't watch at scale — liquidity, volume **acceleration**, buy/sell pressure, unique-buyer growth, price action, turnover — alongside a **risk/rug score** (thin liquidity, FDV ≫ liquidity, sell pressure, too-new, few buyers). Read-only, keyless, agent-callable.

> **Signals, not predictions.** This ranks *observable* on-chain/market activity. It is **not** a price forecast and **not** financial advice. Newly-created tokens are extremely high risk — most lose value or are scams/rugs. Use the risk flags, and never invest more than you can lose.

### What it does

- Scans the newest pools on **Ethereum, BSC, Base, Solana, Polygon, Arbitrum, Avalanche** (keyless GeckoTerminal data).
- For each pool computes a transparent **momentumScore (0–100)** from: liquidity adequacy, **volume acceleration** (recent per-minute rate vs the hour's rate), buy pressure, unique buyers, price momentum, turnover.
- …and a **riskScore (0–100)** from: thin liquidity, FDV-to-liquidity ratio, sell pressure, too-few buyers, too-new-to-read.
- Returns the top candidates ranked by momentum, each with the raw numbers + human-readable **reasons** and **risk flags** + a GeckoTerminal link.

| Field | Meaning |
|---|---|
| `momentumScore` / `momentumLabel` | 0–100, quiet → building → active → heating → hot |
| `riskScore` / `riskLabel` | 0–100, moderate → elevated → high → extreme |
| `ageHours` / `stage` | just-launched / early / establishing / maturing |
| `liquidityUsd`, `fdvUsd`, `fdvToLiquidity` | size & float signals |
| `volumeH1Usd`, `volumeAcceleration` | activity + whether it's accelerating |
| `buysH1` / `sellsH1` / `buyPressure`, `uniqueBuyersH1` | flow + organic interest |
| `priceChangeH1Pct`, `turnover` | price & volume-vs-liquidity |
| `momentumReasons[]` / `riskFlags[]` | why it ranked / what to watch |

### Why not just ask an AI agent?

An agent can look up one token. It **can't** continuously pull the newest pools across seven chains, compute volume acceleration and buy/sell pressure on multi-timeframe buckets, weigh FDV-against-liquidity rug signals, and rank hundreds of brand-new pools — deterministically, in seconds. That cross-source, at-scale scoring is the edge here; your judgment makes the call.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `networks` | array | ethereum, bsc, base, solana | Chains to scan. |
| `maxPagesPerNetwork` | integer (1–5) | 1 | Pages of newest pools per chain (~20 each). |
| `minLiquidityUsd` | integer | 3000 | Ignore pools thinner than this. |
| `maxAgeHours` | integer | 72 | Only pools created within this window. |
| `maxCandidates` | integer | 25 | Top-ranked rows to return. |
| `webhookUrl` | string | | POST the ranked scan here on completion. |

**Example input**

```json
{
  "networks": ["ethereum", "bsc", "base", "solana"],
  "minLiquidityUsd": 5000,
  "maxAgeHours": 48,
  "maxCandidates": 25
}
```

### Output

One row per candidate, ranked by momentum. **Example** (real run, trimmed):

```json
{
  "network": "bsc",
  "dex": "pancakeswap_v2",
  "name": "交易猫 / WBNB",
  "ageHours": 0.08,
  "stage": "just-launched",
  "liquidityUsd": 39974.8,
  "fdvUsd": 153217.62,
  "fdvToLiquidity": 3.8,
  "volumeH1Usd": 23913.51,
  "volumeAcceleration": 3.14,
  "buysH1": 81, "sellsH1": 65, "buyPressure": 0.555,
  "uniqueBuyersH1": 58,
  "priceChangeH1Pct": 140.35,
  "momentumScore": 72, "momentumLabel": "hot",
  "riskScore": 12, "riskLabel": "moderate",
  "momentumReasons": ["volume accelerating (recent rate 3.14x the hourly rate)", "58 unique buyers in the last hour", "price +140% (1h)"],
  "riskFlags": ["too new to read (<15 min)"],
  "geckoTerminalUrl": "https://www.geckoterminal.com/bsc/pools/0x95a8..."
}
```

### Use cases

- **Early-mover discovery** — find pools gaining real, accelerating activity in their first hours.
- **Rug avoidance** — the risk score + flags surface thin-liquidity / thin-float / sell-heavy launches to avoid.
- **A standing feed** — schedule + webhook for a continuous "new & heating" stream to Slack/Discord.
- **AI trading/research agents** — a ranked, scored candidate list to feed into the agent's own analysis.

### Alerts / scheduling

Set `webhookUrl` and schedule the actor (e.g. every 15–30 min) — each run POSTs the freshly-ranked candidates to Make/Zapier/your endpoint, so you see new heating launches as they appear.

### For AI agents / MCP

```
https://mcp.apify.com/?tools=actors,docs,centorprat/new-token-momentum-scanner
```

Loads as `centorprat--new-token-momentum-scanner`. Claude Code:

```
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors centorprat/new-token-momentum-scanner
```

### FAQ

**Does it predict which token will pump?** No. It ranks **current observable signals** (liquidity, accelerating volume, buy pressure, buyers, price). It does not and cannot predict future price — treat it as a discovery + due-diligence aid, not advice.

**Which chains?** Ethereum, BSC, Base, Solana, Polygon, Arbitrum, Avalanche.

**Does it need an API key?** No — keyless public DEX market data.

**How does it handle scams/rugs?** It can't check contract ownership or liquidity locks, but it surfaces the observable risk signals (thin liquidity, FDV ≫ liquidity, sell pressure, too-new, almost no buyers) as `riskFlags` so you can avoid the obvious traps. Always verify the contract yourself.

**What is "volume acceleration"?** The recent per-minute volume rate (last 5 min) divided by the hour's per-minute rate — above 1 means activity is speeding up.

**How fast / how much?** A couple of seconds per scan. Pay-per-event: a base per scan + a small premium per candidate returned.

### Data & attribution

Public DEX market data via the keyless GeckoTerminal API. No keys, no personal data. All outputs are computed signals from public data, not financial advice.

### Related actors

- [Bitcoin Wallet & Transaction Tracer](https://apify.com/centorprat/bitcoin-wallet-transaction-tracer)
- [Ethereum Wallet & Token Tracer](https://apify.com/centorprat/ethereum-wallet-token-tracer)
- [ERC-20 Token Intelligence & Holder Concentration](https://apify.com/centorprat/erc20-token-intelligence)
- [Crypto Address Risk & AML Screener](https://apify.com/centorprat/crypto-address-risk-aml-screener)

# Actor input Schema

## `networks` (type: `array`):

Which chains to scan for brand-new pools. Options: ethereum, bsc, base, solana, polygon, arbitrum, avalanche.

## `maxPagesPerNetwork` (type: `integer`):

How many pages of newest pools to pull per chain (each page ≈ 20 pools). 1 = freshest 20.

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

Ignore pools with less than this liquidity (filters out dust/instant-rug pools).

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

Only include pools created within this many hours (the early window).

## `maxCandidates` (type: `integer`):

How many top-ranked candidates to return.

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

If set, the ranked scan is POSTed here as JSON when the run completes - schedule it for a standing early-mover feed.

## Actor input object example

```json
{
  "networks": [
    "ethereum",
    "bsc",
    "base",
    "solana"
  ],
  "maxPagesPerNetwork": 1,
  "minLiquidityUsd": 3000,
  "maxAgeHours": 72,
  "maxCandidates": 25
}
```

# Actor output Schema

## `candidates` (type: `string`):

One row per newly-created pool that passed the filters: chain/dex/name/token, age + lifecycle stage, liquidity, FDV, FDV-to-liquidity, multi-timeframe volume + acceleration, buy/sell pressure, unique buyers, price change, turnover, a momentumScore (0-100) and riskScore (0-100) with human-readable reasons/flags. Signals, not predictions.

# 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 = {
    "networks": [
        "ethereum",
        "bsc",
        "base",
        "solana"
    ],
    "maxPagesPerNetwork": 1,
    "minLiquidityUsd": 3000,
    "maxAgeHours": 72,
    "maxCandidates": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/new-token-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 = {
    "networks": [
        "ethereum",
        "bsc",
        "base",
        "solana",
    ],
    "maxPagesPerNetwork": 1,
    "minLiquidityUsd": 3000,
    "maxAgeHours": 72,
    "maxCandidates": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/new-token-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 '{
  "networks": [
    "ethereum",
    "bsc",
    "base",
    "solana"
  ],
  "maxPagesPerNetwork": 1,
  "minLiquidityUsd": 3000,
  "maxAgeHours": 72,
  "maxCandidates": 25
}' |
apify call centorprat/new-token-momentum-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/new-token-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/Xj1Bhgat0Fa23eD40/builds/DCOlury5BmDawokaO/openapi.json