# Token Launch Radar (`zinin/token-launch-radar`) Actor Look up any token contract address or ticker across DEXes and get liquidity, 24h volume, pair age, a 0-100 quality score and risk flags. Powered by DexScreener's public API. No key, no wallet, no on-chain node. Not financial advice. - **URL**: https://apify.com/zinin/token-launch-radar.md - **Developed by:** [Tim Zinin](https://apify.com/zinin) (community) - **Categories:** Automation, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.25 / 1,000 launch founds 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/platform/actors/running/actors-in-store#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 ## Token Launch Radar — DEX Liquidity, Volume & Risk Score **Is this token worth a second look, or a stat you can skip?** Point this Actor at a token contract address or ticker and get back liquidity, 24h volume, pair age, a 0-100 quality score and plain-English risk flags — read straight from DexScreener's public API. > ⚠️ **Not financial advice.** `qualityScore` is a heuristic built from liquidity, volume > and age — it is not a signal to buy, sell, or trust a token. Always do your own > research. ### What you get - **A consistent score instead of a gut feeling.** 0-100 `qualityScore` from liquidity, 24h volume and pair age, plus plain-English `riskFlags` (very low liquidity, abnormal volume/liquidity ratio, brand-new pair, sharp 24h decline, large uncirculated supply). - **Filters built in.** Drop anything below a liquidity floor (`minLiquidityUsd`) or older than a freshness window (`maxAgeHours`) — hunt fresh launches without eyeballing a hundred pairs by hand. - **Works on contract addresses or tickers** — EVM `0x…`, Solana base58, or a plain search term like `PEPE`. One row per entry. - **Chain-fork noise filtered out.** PulseChain is a full state-fork of Ethereum, so pre-fork Ethereum addresses have an unrelated "twin" there with completely different liquidity — that twin is dropped unless it's the only match for the input. - **Ticker ambiguity is disclosed, not hidden.** A contract address is a real identifier; a ticker like `TRUMP` or `PEPE` is not — DexScreener can and does return unrelated tokens that merely share a symbol (real example: searching `TRUMP` surfaces a token actually named "MAGA" as the highest-liquidity hit). When you search by ticker/name, the row tells you how many distinct tokens it found under that symbol (`candidateTokenCount`), the real name of the one it scored (in `summary` and `name`), and the alternates it passed over (`candidates`). Pass a contract address instead and there's nothing to disambiguate — `matchBasis: "address"`. - **Ticker search is not exhaustive, and the token found can carry a different symbol than you typed.** DexScreener's search caps a single query at roughly 30 raw results, and it can index a token's own symbol with a leading `$` — a bare-symbol search then misses it completely. This Actor also tries the `$`-prefixed form and merges both result sets. That broadens the candidate set but does not identify an official contract: a high-liquidity result with the expected name can still be a different token address. It still isn't a full survey — `candidateTokenCount` means "found within DexScreener's own (capped) search," not "every token that exists." And separately: the token DexScreener does return for your query can itself carry a symbol that doesn't match what you typed — search `PEOPLE` and the top hit's own symbol is `PRN`, with the real PEOPLE token visible only in `candidates`. Read both `name` **and** `symbol` on the row; never assume either one matches your query. - No key, no wallet, no on-chain node — just DexScreener's free public API. - Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON, CSV or Excel, or push results straight into your own pipeline. ### How to run it 1. Click **Try for free** — no card needed on the free plan. 2. Paste contract addresses or tickers into **Tokens**, one per line. Optionally set a liquidity floor or an age ceiling. 3. Press **Start**. Results appear in the dataset — read them in the UI, pull them from the API, or push them onward with a webhook. ### Pricing Pay-per-event: **$0.005 per run start + $0.005 per token checked**. No monthly seat. 100 tokens cost about **$0.51**; 1,000 tokens about **$5.01**. A token with no usable pair, or one filtered out by `minLiquidityUsd` / `maxAgeHours`, is still returned with `found: false` and the reason — and it is **not** charged. You pay for pairs that actually exist, not for lookups. ### 简体中文说明 输入代币合约地址（EVM `0x…` 或 Solana base58）或代币代码（如 `PEPE`），此 Actor 会直接从 DexScreener 的公开 API 读取该代币当前交易对的流动性、24 小时交易量、交易对存在时长，并汇总成一个 0-100 的 `qualityScore`（质量评分），同时给出通俗易懂的风险提示 `riskFlags`（例如流动性过低、成交量/流动性比例异常、交易对刚创建、24 小时跌幅过大、未流通供应量过大）。**`qualityScore` 不构成财务建议**，只是基于流动性、成交量和交易对年龄这三项公开指标的启发式打分，请自行研究（DYOR）。 可以设置 `minLiquidityUsd`（流动性下限）和 `maxAgeHours`（只看多长时间内新建的交易对）两个过滤条件，方便筛选新上线的代币。同一枚代币若在多条链上有交易对，本 Actor 会取流动性最高的一个；PulseChain 是以太坊主网的完整分叉，同一个合约地址在 PulseChain 上会有一个流动性完全不同的"分身"交易对，除非这是唯一匹配结果，否则会被过滤掉，避免这个分身干扰对知名代币的判断。 计费为按事件付费：每次运行 $0.005，每个成功查到交易对的代币 $0.005（`result-found`）。查不到可用交易对，或被 `minLiquidityUsd`/`maxAgeHours` 过滤掉的代币，会以 `found: false` 返回原因，**不计费**。100 个代币约 $0.51，1000 个约 $5.01。 **这不是什么。** 本 Actor 不审计合约代码、不检查所有者/铸币权限，也不模拟买卖来检测蜜罐（honeypot）——这些属于 Rug-Pull Risk Scorer（见下方 Related Actors）的范围。 ### Input | Field | Type | Description | |-------|------|-------------| | `tokens` | array of strings | Contract addresses (EVM `0x…` or Solana base58) or tickers/search terms. One row per entry. Up to 100. | | `minLiquidityUsd` | integer | Drop the token's best pair if its liquidity is below this. `0` = no filter (default). | | `maxAgeHours` | integer | Only keep pairs created within this many hours — hunt fresh launches. Leave empty for no age filter. | | `maxConcurrency` | integer | Parallelism (1–20, default 5). | ```json { "tokens": [ "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE" ] } ``` ### Output One dataset row per input. This is a real row from a real run: ```json { "input": "PEPE", "found": true, "chainId": "solana", "matchBasis": "ticker-search", "candidateTokenCount": 42, "candidates": [ { "chainId": "ethereum", "dexId": "uniswap", "tokenAddress": "0x6982...1933", "name": "Pepe", "symbol": "PEPE", "liquidityUsd": 21376038.83, "pairAddress": "0xA43fe...cCEc9f" } ], "dexId": "meteora", "pairAddress": "E9H1rNgCSXHsZxWBBUrq4piBaYSZAymm8c4SVWrwWWPw", "name": "Pepe", "symbol": "PEPE", "tokenAddress": "Ej47F4UxHb78mWaHRtLGuFGRvAmR4sXjEHeZvZbWNn53", "priceUsd": 1.247e-05, "liquidityUsd": 111231543.6, "volumeH24": 3.99, "priceChangeH24": -0.02, "fdv": 112231555, "marketCap": 112231555, "ageHours": 8629.8, "qualityScore": 60, "riskFlags": [], "summary": "PEPE on solana (meteora) — token found: \"Pepe\" — liquidity $111,231,544, 24h vol $4, 359.6d old, quality 60/100 — matched by ticker/name search — found 42 distinct token(s) under this symbol/name within DexScreener's own (capped, non-exhaustive) search results, picked the highest-liquidity one found here; NOT verified as the specific token you meant, and the real one you meant may not even be in this set — see \"candidates\". Not financial advice — heuristic score, DYOR.", "checkedAt": "2026-08-04T17:05:28.706Z" } ``` | Field | Description | |---|---| | `input` | The address or search term you passed | | `found` | Whether a usable pair was found (and passed your filters) | | `chainId` / `dexId` / `pairAddress` | Where the best pair trades | | `matchBasis` | `"address"` — the input itself was the identifier, nothing to disambiguate. `"ticker-search"` — the input was free text matched by DexScreener's search index; a symbol is not unique, see `candidates`. | | `candidateTokenCount` | Only set for `matchBasis: "ticker-search"`: how many DISTINCT tokens (not pools) this Actor **found under this symbol/name within DexScreener's own search results** at query time — that search is capped (~30 raw pairs per query, up to ~60 once the bare and `$`-prefixed forms are merged) and not exhaustive, so this is a lower bound on real usage of the symbol, never a claim that no other token exists. `null` for an address lookup. | | `candidates` | Only set for `matchBasis: "ticker-search"` with more than one match: up to 5 of the other distinct tokens found under the same symbol/name within that same (capped) search, ranked by liquidity, that were NOT picked — each with its own `chainId`, `tokenAddress`, `name`, `symbol` and `liquidityUsd`. The token you actually meant can be missing from this list entirely if DexScreener's own search never surfaced it. | | `name` / `symbol` / `tokenAddress` | The token itself — `name` is the field that catches a symbol-only mismatch a ticker alone can hide (e.g. `symbol: "TRUMP"` can be the real thing or, live-verified, a token actually named "MAGA") | | `priceUsd` | Current price in USD | | `liquidityUsd` / `volumeH24` / `priceChangeH24` | Pool liquidity, 24h volume, 24h price change | | `fdv` / `marketCap` | Fully diluted valuation and market capitalization reported by DexScreener; either can be `null` when the source does not provide it | | `ageHours` | Hours since the pair was created | | `qualityScore` | 0-100 heuristic from liquidity, volume and age | | `riskFlags` | Plain-English warnings (low liquidity, abnormal volume ratio, brand-new, sharp decline, large uncirculated supply) | | `summary` | Human-readable one-liner, always says how the token was matched — by address, or by ticker search among N candidates with the real name it found — and ends with a not-financial-advice disclaimer | | `checkedAt` | ISO timestamp for when this result was checked | | `error` | Present only when `found: false` — why no row was returned | ### How the best pair is picked A token can trade on many pairs across many chains. This Actor takes the one with the highest liquidity — with one guardrail: PulseChain is a full state-fork of Ethereum mainnet, so pre-fork Ethereum contract addresses have an unrelated "twin" on PulseChain with completely different liquidity and holders. Left in, that twin can silently outrank the real chain by liquidity for well-known tokens. PulseChain pairs are excluded unless they're the only match for that input. When you search by contract address, that's the whole story — the address IS the token's identity, nothing to disambiguate. When you search by ticker or name, "highest liquidity" is picking among every DISTINCT TOKEN found under that symbol within DexScreener's own search results — DexScreener enforces no ticker uniqueness, so a fresh memecoin can and does launch under a well-known symbol. This Actor does not try to guess which one you "really" meant: it reports the token it picked by name (`name`, and inline in `summary`), how many other tokens it found sharing the symbol (`candidateTokenCount`), and up to 5 of the ones it passed over (`candidates`) — so a mismatch is visible in the row instead of hiding behind a ticker that looked right. **"Found under that symbol" is not the same as "every token that exists."** DexScreener's own search caps a single query at roughly 30 raw results, and it can index a token's own symbol with a leading `$` — a bare-symbol search then misses it completely. Querying both the bare and `$`-prefixed forms can materially change which WIF contracts appear and which candidate ranks first. This Actor merges both result sets, but that widens the net; it does not identify an official token and does not make it infinite: `candidateTokenCount` still means "found within DexScreener's own search," never "how many tokens use this symbol." Separately, the token DexScreener finds for your exact query can itself carry a DIFFERENT symbol than what you typed — search `PEOPLE` and the top hit's own symbol is `PRN` ("Peoples Reserve"), with the real ConstitutionDAO `PEOPLE` token ranking lower by liquidity and surfacing only in `candidates`. Read both `name` **and** `symbol` on the row before trusting either. ### API Start a run with a bearer token and explicit JSON input: ```bash curl -sS -X POST 'https://api.apify.com/v2/acts/zinin~token-launch-radar/runs?waitForFinish=60' \ -H "Authorization: Bearer $APIFY_TOKEN" \ -H 'Content-Type: application/json' \ --data '{"tokens":["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48","PEPE"]}' ``` Read Dataset rows using the returned `defaultDatasetId`: ```bash curl -sS "https://api.apify.com/v2/datasets/$DEFAULT_DATASET_ID/items?clean=true&format=json" \ -H "Authorization: Bearer $APIFY_TOKEN" ``` ### MCP For an Apify MCP client exposing the standard `call-actor` tool, send this exact payload: ```json { "name": "call-actor", "arguments": { "actor": "zinin/token-launch-radar", "input": { "tokens": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE"] } } } ``` #### Related tools Related tools for adjacent workflows in crypto and wallets. | Actor | What it does | |---|---| | [Live Price Oracle](https://apify.com/zinin/live-price-oracle) | Pair it in the crypto and wallets workflow: Current USD price for any token by contract address or ticker: 24h change, liquidity, volume, best DEX pair | | [Wallet Airdrop Readiness Score](https://apify.com/zinin/wallet-airdrop-profile) | Pair it in the crypto and wallets workflow: Profile a wallet on-chain: age, tx activity, contract & token diversity -> a 0-100 airdrop-farming... | | [Rug Pull Risk Scorer](https://apify.com/zinin/rug-pull-scorer) | Pair it in the crypto and wallets workflow: Score ERC-20/BEP-20 token rug-pull risk from honeypot.is simulation + DexScreener liquidity/age | | [Whale Wallet Tracker](https://apify.com/zinin/whale-wallet-tracker) | Pair it in the crypto and wallets workflow: Track large native ETH and ERC-20 token movements for any wallet(s) via Etherscan's multichain API (bring... | ### FAQ **Does it need an API key or wallet?** No — DexScreener's public API is free and keyless. **How fresh is the data?** As fresh as DexScreener's own feed — typically seconds to a couple of minutes behind the DEX itself. **Is `qualityScore` financial advice?** No. It's a heuristic built from three public metrics (liquidity, volume, age). It does not account for contract risk, team behavior, or anything off-chain. Always DYOR. **I searched by ticker — is `qualityScore` definitely scoring the token I meant?** Not necessarily, and the row tells you so. Check `matchBasis`: `"ticker-search"` means the symbol/name you searched matched several distinct tokens and this Actor scored the highest-liquidity one, not the one it "knows" you meant (it doesn't know). Read `name` **and `symbol`** (a found token's own symbol can differ from what you typed — see `PEOPLE` → `PRN` below) and `candidates` (the others it passed over) before trusting the score. Pass the contract address instead (`matchBasis: "address"`) whenever you have it — that removes the ambiguity entirely. **Is `candidateTokenCount` a complete count of every token using this symbol?** No — it's how many DexScreener's own search surfaced, and that search is capped at roughly 30 raw results per query (about 60 once this Actor merges the bare and `$`-prefixed forms). A token can be entirely invisible to a bare-symbol search if DexScreener indexes it with a leading `$`; this Actor checks both forms to improve coverage. Treat the count as "at least this many found," never "exactly this many exist," and treat the selected `tokenAddress` as unverified until you compare it with an independent source. Separately, the token found for your query can itself carry a different symbol than what you typed — `PEOPLE` currently resolves to a token whose own symbol is `PRN`, so check `symbol` too, not just `name`. **Can I call it from an AI agent?** Yes — it's a standard Apify Actor, callable via the Apify API or the Apify MCP server. **What this is NOT.** It does not audit contract code, check ownership/mint functions, or simulate a buy/sell to detect a honeypot — for that on EVM tokens, see Rug-Pull Risk Scorer below. Found a wrong result, or need a check we don't run? Open an issue on this Actor's page. *** Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin). # Actor input Schema ## `tokens` (type: `array`): Token contract addresses (e.g. `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`) or search terms/tickers (e.g. `PEPE`). One row per entry. ## `minLiquidityUsd` (type: `integer`): Drop the token's best pair if its liquidity is below this. 0 = no filter. ## `maxAgeHours` (type: `integer`): Only keep pairs created within this many hours — use it to hunt fresh launches. Leave empty for no age filter. ## `maxConcurrency` (type: `integer`): How many tokens to look up in parallel. ## Actor input object example ```json { "tokens": [ "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE" ], "minLiquidityUsd": 0, "maxConcurrency": 5 } ``` # Actor output Schema ## `results` (type: `string`): API URL for the default dataset items produced by this run. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "tokens": [ "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE" ] }; // Run the Actor and wait for it to finish const run = await client.actor("zinin/token-launch-radar").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "tokens": [ "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE", ] } # Run the Actor and wait for it to finish run = client.actor("zinin/token-launch-radar").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "tokens": [ "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE" ] }' | apify call zinin/token-launch-radar --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=zinin/token-launch-radar", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/eiazRDQkGhYtaTI8j/builds/NIsibbJ150gj2N1Xe/openapi.json