# DEX New Token Scanner — Trending & Boosted via DexScreener (`gochujang/dex-new-token-scanner`) Actor

Detects newly trending DEX tokens across Solana, Base, Ethereum, BSC using DexScreener boosted and profile feeds. Computes hype score from boost amount, volume/liquidity ratio, and price momentum. No API key. $0.002/token.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

### What does DEX New Token Scanner do?

**DEX New Token Scanner** detects newly launched and trending tokens across **Solana, Base, Ethereum, and BNB Chain** by combining DexScreener's boosted token feed (paid promotions with real trading volume) and token profile feed (recently updated metadata) into a unified, deduplicated stream of **early-stage token launches**. For each candidate it fetches live pair metrics — price, market cap, volume, liquidity, price momentum — and computes a **hype score**, **rug pull risk score**, **launch quality score**, and **gem probability classification** so you can filter signal from noise at scale. No API key required.

### Why use DEX New Token Scanner?

- **Dual-feed early detection** — the actor combines DexScreener's boost feed (projects paying for visibility) and profile feed (developer-updated metadata) to catch new listings from two angles, giving broader coverage than either feed alone.
- **Rug pull risk scoring with contract-level flags** — `rug_pull_risk_score` (0–100), `rug_pull_risk` label (critical / high / moderate / low / minimal), and `contract_risk_flags` (mint\_enabled, blacklist\_function, proxy\_contract, etc.) are computed per token to surface red flags instantly.
- **Gem probability classification** — `gem_probability` (potential\_gem / worth\_watching / speculative / avoid) combines launch quality, momentum velocity, and risk profile into a single actionable signal for filtering.
- **Multi-chain cross-narrative scanning** — scan all four chains simultaneously to detect which chain is seeing the most new launches (`chain_with_most_launches`) and whether a narrative (AI tokens, gaming, memes) is concentrating on a specific chain.
- **Early signal flag for hot launches** — `early_signal` is `true` when a token launched less than 60 minutes ago with strong momentum and acceptable risk — the highest-time-sensitivity alert in the dataset.

### How to use DEX New Token Scanner

1. Go to the [Apify Store](https://apify.com/store) and find **DEX New Token Scanner**.
2. Click **Try for free** to open the actor in Apify Console.
3. Configure inputs: select `chains`, set `minVolumeUsd` and `minLiquidityUsd` to filter out rug-pulls and dead tokens.
4. Click **Start** — the run completes in 30–90 seconds depending on the number of candidate tokens.
5. Download results as JSON or CSV, or schedule recurring runs every 15–30 minutes for live monitoring.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `chains` | array | `["solana","base","ethereum","bsc"]` | Chains to scan. Supported: solana, base, ethereum, bsc. |
| `minVolumeUsd` | number | `10000` | Minimum 24h volume in USD. Filters dead and illiquid tokens. |
| `minLiquidityUsd` | number | `5000` | Minimum liquidity in USD. Ensures the token is actually tradeable. |

### Output

```json
[
  {
    "type": "market_summary",
    "tokens_scanned": 94,
    "tokens_qualified": 22,
    "chains_covered": ["solana", "base", "ethereum", "bsc"],
    "total_new_tokens_24h": 8,
    "avg_initial_liquidity_usd": 42500,
    "high_quality_launches": 3,
    "potential_gems": [{ "token_symbol": "NOVA", "chain": "base" }],
    "chain_with_most_launches": "solana",
    "avg_24h_return_pct": 38.4,
    "fetched_at": "2026-09-02T08:00:00Z"
  },
  {
    "rank": 1,
    "source": "boosted",
    "boost_amount": 500,
    "chain": "solana",
    "dex": "raydium",
    "token_address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
    "token_name": "Nova Protocol",
    "token_symbol": "NOVA",
    "pair_address": "4k5yPFtrdSqiKnXgVqf2A5ZGHM5iFuCkm8G4GsVKpqm",
    "price_usd": "0.00482",
    "market_cap_usd": 4820000,
    "fdv_usd": 9640000,
    "volume_24h_usd": 1840000,
    "liquidity_usd": 285000,
    "price_change_1h_pct": 18.4,
    "price_change_6h_pct": 142.7,
    "price_change_24h_pct": 412.3,
    "hype_score": 32.6,
    "rug_pull_risk_score": 40,
    "safety_label": "caution",
    "launch_momentum": 2.14,
    "holder_distribution": "normal",
    "time_since_launch_minutes": 38.5,
    "early_signal": true,
    "launch_quality_score": 62,
    "rug_pull_risk": "moderate",
    "initial_liquidity_health": "adequate",
    "momentum_velocity": "strong",
    "holder_distribution_signal": "moderate",
    "liquidity_lock_status": "no_lock_detected",
    "contract_risk_flags": ["ownership_not_renounced"],
    "gem_probability": "worth_watching",
    "url": "https://dexscreener.com/solana/4k5yPFtrdSqiKnXgVqf2A5ZGHM5iFuCkm8G4GsVKpqm",
    "fetched_at": "2026-09-02T08:00:00Z"
  }
]
```

### Data fields

| Field | Description |
|-------|-------------|
| `source` | Data origin: `boosted` (paid promotion) or `profile` (metadata update) |
| `boost_amount` | DexScreener boost credits spent by the project (higher = more paid attention) |
| `chain` | Chain identifier: solana, base, ethereum, bsc |
| `dex` | DEX where the pair trades (raydium, uniswap, pancakeswap, etc.) |
| `token_address` | Token contract address |
| `token_name` / `token_symbol` | Token name and ticker |
| `price_usd` | Current token price in USD |
| `market_cap_usd` | Circulating market cap in USD |
| `fdv_usd` | Fully diluted valuation in USD |
| `volume_24h_usd` | 24-hour trading volume in USD |
| `liquidity_usd` | Current DEX liquidity in USD |
| `price_change_1h_pct` | Price change in the last 1 hour (%) |
| `price_change_6h_pct` | Price change in the last 6 hours (%) |
| `price_change_24h_pct` | Price change in the last 24 hours (%) |
| `hype_score` | Composite signal: boost × (volume/liquidity) × (1 + price\_change/100) |
| `rug_pull_risk_score` | 0–100 rug risk score (higher = riskier) |
| `safety_label` | Risk classification: safe / caution / high-risk / likely-rug |
| `launch_momentum` | Volume in last 1h / initial liquidity — speed of early trading |
| `holder_distribution` | Holder concentration: distributed / normal / concentrated |
| `time_since_launch_minutes` | Minutes since the pair was created on-chain |
| `early_signal` | True if launched <60min ago with strong momentum and acceptable risk |
| `launch_quality_score` | 0–100 composite launch quality (liquidity + lock + audit + socials + mint) |
| `rug_pull_risk` | Categorical risk label: minimal / low / moderate / high / critical |
| `initial_liquidity_health` | Liquidity depth: deep / adequate / thin / micro |
| `momentum_velocity` | Price momentum: explosive / strong / moderate / slow / declining |
| `holder_distribution_signal` | Holder quality: well\_distributed / moderate / concentrated / whale\_dominated |
| `liquidity_lock_status` | Lock status: locked\_long / locked\_short / unlocked / no\_lock\_detected |
| `contract_risk_flags` | List of detected contract risks (mint\_enabled, blacklist\_function, etc.) |
| `gem_probability` | Gem classification: potential\_gem / worth\_watching / speculative / avoid |
| `url` | DexScreener pair URL for manual review |

### Cost estimation

| Scenario | Tokens returned | Cost per run |
|----------|----------------|--------------|
| Small (quiet market, 4 chains) | 5–15 tokens | $0.01–$0.03 |
| Medium (normal activity) | 15–30 tokens | $0.03–$0.06 |
| Large (high hype, many launches) | 30–60 tokens | $0.06–$0.12 |

Pricing is **$0.002 per qualified token** (tokens that pass the volume and liquidity filters). A typical run with 20 qualifying tokens costs $0.04. Running hourly costs under $3/month in most market conditions.

### FAQ

**What is the difference between `boosted` and `profile` sources?**
`boosted` tokens have paid DexScreener to display a boost badge — it indicates the project team is willing to spend money to attract attention and that real trading volume exists (DexScreener requires this for boosts). `profile` tokens have recently updated their metadata (description, socials, website) — it indicates active developer marketing. Both are early signals of upcoming attention; neither is a safety guarantee.

**How is the hype score calculated?**
`hype_score = boost_amount × (volume_24h / liquidity) × (1 + |price_change_24h| / 100)`. A token with a high boost, large trading volume relative to its liquidity pool size, and extreme price movement scores highest. It is a relative attention signal, not a buy signal.

**Can I filter for only "safe" new tokens?**
No filter makes new tokens truly safe — early-stage DEX tokens carry substantial risk by nature. You can narrow the field by filtering `rug_pull_risk` to `low` or `minimal`, `launch_quality_score` >= 60, and `liquidity_lock_status` to `locked_long`. Even then, independent on-chain verification is essential before trading.

**Disclaimer:** This actor provides data for informational and research purposes only. New token launches are extremely high-risk speculative assets. Rug pull risk scores and safety labels are computed heuristics — they do not guarantee safety or detect all fraud. Never invest more than you can afford to lose in new or unaudited tokens. This is not financial advice.

Keywords: DEX new token scanner, new token listings, DexScreener new tokens, Solana new tokens, Base new token launches, meme coin detector, early token discovery, rug pull risk score, hype score, DEX token tracker

***

### Related actors

- [DexScreener Token Screener](https://apify.com/gochujang/dexscreener-token-screener) — Apply custom filters on top of the new token launches discovered by this actor
- [Memecoin Launch Detector](https://apify.com/gochujang/memecoin-launch-detector) — Solana-focused memecoin launches for deeper coverage of the highest-velocity chain
- [Token Holder Tracker](https://apify.com/gochujang/token-holder-tracker) — Holder distribution for new tokens as a rug pull due diligence step

### Feedback

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

# Actor input Schema

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

Blockchain networks to scan (DexScreener chain IDs).

## `minVolumeUsd` (type: `integer`):

Minimum 24h trading volume to include a token.

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

Minimum pool liquidity to include a token.

## Actor input object example

```json
{
  "chains": [
    "solana",
    "base",
    "ethereum",
    "bsc"
  ],
  "minVolumeUsd": 10000,
  "minLiquidityUsd": 5000
}
```

# 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/dex-new-token-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/dex-new-token-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 '{}' |
apify call gochujang/dex-new-token-scanner --silent --output-dataset

```

## MCP server setup

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