# Dexscreener Scraper — DEX Prices, Liquidity, New Pairs, Boosts (`yadroo/dexscreener-tokens`) Actor

DEX Screener data for 45+ chains: search tokens, all pools of a token, pair monitoring, boosted/new/CTO/advertised tokens with market data, trending metas and paid-order checks. Liquidity, volume, market cap and age filters, risk flags. No API key.

- **URL**: https://apify.com/yadroo/dexscreener-tokens.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 result items

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

Live on-chain market data from DEX Screener for 45+ chains (Solana, Ethereum, BNB Chain, Base, Arbitrum, Sui, TON, Tron, Hyperliquid…):
search any token, pull every pool of a token, monitor specific pairs, and track what is being promoted right now — boosted tokens,
new profiles, community takeovers, paid ads and trending narratives — with liquidity/volume/age filters and risk flags.
Uses the official public DEX Screener API. No API key, no proxy, no browser.

### Use cases

- **Price & liquidity monitoring** — scheduled `pairs` run over your pools; alert on price moves or liquidity drops.
- **New-launch scouting** — `latestBoosts` / `profiles` with market data, filtered by liquidity, market cap and pair age.
- **Token due diligence** — all pools of a token (`tokenPairs`), risk flags (`suspicious_liquidity`, `sell_pressure`, `no_sells_24h`), and paid promotion history (`orders`).
- **Finding the real contract** — search a ticker, keep only the most liquid pair per token to separate the original from knock-offs.
- **Narrative research** — trending metas (AI, dog, x402…) with market cap and 24h change, then the pairs inside each meta.
- **Listing / BD lead-gen** — tokens that just paid for boosts or ads, with website, Twitter and Telegram links.

### Input

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string | `search` | `search`, `tokens`, `tokenPairs`, `pairs`, `boosted`, `latestBoosts`, `profiles`, `profileUpdates`, `takeovers`, `ads`, `metas`, `meta`, `orders` (see Reference) |
| `queries` | string\[] | `["AERO"]` (prefill) | mode=search: names, symbols, `SOL/USDC`, token or pair addresses (DEX Screener returns up to 30 pairs per query) |
| `chainId` | string | `""` | Chain id from the table below. Letter case and display names are accepted, and so are the aliases `eth`, `sol`, `bnb`, `binance`, `arb`, `matic`, `op`, `avax`, `sei`, `hype`, `xrp`; the status message shows how the value was read. An id not on the list is passed to DEX Screener as typed, with a note in the status (DEX Screener adds chains often); if it is one or two letters away from a known id (`etherum`) and the run finds nothing, the run fails with "did you mean". Required for `tokens`, `tokenPairs`, `pairs`, `orders`; a filter for `search`, `meta` and the token lists; ignored by `metas`. |
| `expandChainSearch` | boolean | `true` | mode=search + `chainId`: widen past the 30-pair search cap — also search `<query>/<chain quote>` (e.g. `PEPE/WETH`, `PEPE/USDC`) and pull the pools of each matching token on that chain via `/token-pairs`. `false` = plain search, then filter |
| `chainSearchTokens` | integer | `10` | 0–30 matching tokens (most liquid first) whose pools are fetched when widening |
| `tokenAddresses` | string\[] | `[]` | mode=tokens / tokenPairs / orders. Any number (batched 30 per request in `tokens`). In `tokens` every row describes the queried token (see Reference → Modes) |
| `pairAddresses` | string\[] | `[]` | mode=pairs. Always returned (filters are not applied); pairs DexScreener does not know are listed in `SUMMARY.notFound` (not charged) |
| `metaSlugs` | string\[] | `[]` | mode=meta, e.g. `ai`, `dog`, `x402` (run mode=metas for the live list) |
| `minLiquidityUsd` | integer | `1000` | Set 0 to keep pairs/tokens without liquidity data |
| `maxLiquidityUsd` | integer | — | |
| `minVolume24hUsd` | integer | — | |
| `minMarketCapUsd` / `maxMarketCapUsd` | integer | — | Market cap, or FDV when market cap is missing |
| `minTxns24h` | integer | — | Buys + sells in 24 h |
| `minPriceChange24h` / `maxPriceChange24h` | integer | — | Percent, e.g. `20` or `-20` |
| `minAgeHours` / `maxAgeHours` | integer | — | Pair age; `maxAgeHours: 24` = launched in the last day |
| `dexIds` | string\[] | `[]` | e.g. `uniswap`, `aerodrome`, `raydium`, `pumpswap`, `meteora`, `orca`, `pancakeswap`, `sushiswap`, `quickswap` |
| `quoteSymbols` | string\[] | `[]` | e.g. `USDC`, `USDT`, `WETH`, `SOL`, `WBNB` |
| `sortBy` | string | `liquidity` | `liquidity`, `volume24h`, `volume1h`, `marketCap`, `fdv`, `priceChange5m`, `priceChange1h`, `priceChange24h`, `txns24h`, `buySellRatio24h`, `pairAge`, `boosts`, `none` (nulls always last). In list modes `boosts`/`none` keep DEX Screener's own ranking |
| `sortOrder` | string | `desc` | `desc`, `asc` (`pairAge` + `asc` = newest first) |
| `onePairPerToken` | boolean | `false` | Keep only the most liquid pair of each token |
| `limitPerQuery` | integer | `10` | 1–500 items per query / token / meta / list |
| `maxItems` | integer | `100` | 1–10000, hard cap for the whole run |
| `includeMarketData` | boolean | `true` | List modes: attach price, liquidity, volume, market cap, age of each token's most liquid pair |
| `includeInfo` | boolean | `true` | Pair modes: `imageUrl`, `websites`, `socials` |
| `newPairHours` | integer | `24` | Threshold for the `new_pair_<N>h` flag (1–720) |
| `fields` | string\[] | `[]` | Keep only these top-level fields, in this order. `id`, `query`, `chainId`, `found`, `url`, `fetchedAt` are always kept (first, unless you list them). Letter case is forgiven; an unknown name, or a list with no field this mode's rows have, stops the run with a suggestion before any row is charged. Names: Reference → Output fields |

In list modes the market filters (`minLiquidityUsd`, volume, market cap, price change, age) are applied to the token's most liquid pair, and only when `includeMarketData` is on. `dexIds`, `quoteSymbols` and `minTxns24h` do not apply to list modes; when they are set, the status message says they were ignored. Mode `pairs` applies no filters (a monitored pool is always returned).

### Reference

#### Modes

| Mode | Source endpoint | Items |
|---|---|---|
| `search` | `/latest/dex/search` | Pairs per query |
| `tokens` | `/tokens/v1/{chain}/{addresses}` | The queried token's own pairs (it is the base token, so `symbol` and `priceUsd` are its own). When DEX Screener lists the token only as the quote token of its pools, those pools are turned around: its USD price = base price ÷ native price, buys and sells swap, and the row is flagged `price_from_quote_side` (change %, FDV, market cap, boosts and profile links are then `null`: they belong to the other token). With `onePairPerToken`, one row per address |
| `tokenPairs` | `/token-pairs/v1/{chain}/{address}` | Pools that contain each token, on either side (DEX Screener returns the top 30); `querySide` says whether the token is the base (`priceUsd` is its price) or the quote (`priceUsd` is the other token's) |
| `pairs` | `/latest/dex/pairs/{chain}/{pairs}` | One per requested pair |
| `boosted` | `/token-boosts/top/v1` | Tokens with most active boosts |
| `latestBoosts` | `/token-boosts/latest/v1` | Newest boost purchases |
| `profiles` / `profileUpdates` | `/token-profiles/latest/v1`, `/token-profiles/recent-updates/v1` | Newest / recently updated profiles |
| `takeovers` | `/community-takeovers/latest/v1` | Latest community takeovers |
| `ads` | `/ads/latest/v1` | Latest paid ads (`tokenAd`, `trendingBarAd`) |
| `metas` | `/metas/trending/v1` | Trending narratives |
| `meta` | `/metas/meta/v1/{slug}` | Pairs in each narrative |
| `orders` | `/orders/v1/{chain}/{address}` | One summary per token. DEX Screener answers "no orders" for any chain id, even a misspelt one, so on a chain not in the list below the orders are looked up only when DEX Screener lists at least one of the tokens there |

List endpoints (boosts, profiles, takeovers, ads) hold only the latest ~30 entries across all chains, so a chain filter can leave few results.

#### Chains (`chainId`)

Confirmed against live API responses in September 2026:

| | | | |
|---|---|---|---|
| `solana` | `ethereum` | `bsc` | `base` |
| `arbitrum` | `polygon` | `optimism` | `avalanche` |
| `robinhood` | `pulsechain` | `sui` | `ton` |
| `tron` | `hyperliquid` | `hyperevm` | `sonic` |
| `fantom` | `cronos` | `linea` | `blast` |
| `zksync` | `scroll` | `mantle` | `manta` |
| `abstract` | `berachain` | `unichain` | `worldchain` |
| `monad` | `seiv2` | `aptos` | `movement` |
| `near` | `injective` | `celo` | `metis` |
| `kava` | `starknet` | `stacks` | `multiversx` |
| `flare` | `conflux` | `telos` | `beam` |
| `algorand` | `xrpl` | `hedera` | |

DEX Screener adds chains regularly; the chain id is the first path segment of a pair URL (`dexscreener.com/<chainId>/…`).

#### Flags (`flags[]`, pair items)

| Flag | Rule |
|---|---|
| `low_liquidity` / `no_liquidity_data` | Liquidity < $10k / not reported |
| `suspicious_liquidity` | Liquidity ≥ $100k but 24h volume < 0.1 % of it — typical of knock-off or mispriced pools |
| `new_pair_<N>h` | Pair younger than `newPairHours` |
| `sell_pressure` | 24h buys < half of sells |
| `no_sells_24h` | > 20 buys and 0 sells in 24 h (possible honeypot — verify) |
| `extreme_price_move_24h` | abs(24h change) ≥ 50 % |
| `volume_over_10x_liquidity` | 24h volume > 10 × liquidity (wash trading or a hype spike) |
| `no_profile` / `no_socials` | No DEX Screener token profile / profile without links |
| `price_from_quote_side` | mode=tokens: the queried token is the quote token of this pool; the row is the pool turned around (see Modes) |

Flags are heuristics for triage, not verdicts.

#### Output fields

| Field | Items | Description |
|---|---|---|
| `id`, `query`, `found` | all | Stable id (`chain:pair`, `chain:token`, `meta:slug`); input that produced the item (not in list and metas items); lookup result (`found: true` on every item — inputs with no match or that failed are not items, see Limits & FAQ) |
| `chainId`, `dexId`, `labels`, `pairAddress`, `url` | pairs | Where the pool lives (`labels`: v2/v3/v4, CLMM, DLMM…) |
| `symbol`, `name`, `tokenAddress`, `quoteSymbol`, `quoteAddress` | pairs, lists | Base and quote token |
| `priceUsd`, `priceNative`, `change5m`, `change1h`, `change6h`, `change24h` | pairs, lists | Price and % change (lists: `change1h`, `change24h`) |
| `volume5m`, `volume1h`, `volume6h`, `volume24h`, `buys5m`, `sells5m`, `buys1h`, `sells1h`, `buys24h`, `sells24h`, `txns24h`, `buySellRatio24h` | pairs | Activity (lists and metas: `volume24h`) |
| `liquidityUsd`, `liquidityBase`, `liquidityQuote`, `volumeToLiquidity24h`, `fdv`, `marketCap` | pairs, lists | Depth and valuation |
| `pairCreatedAt`, `ageHours`, `boosts`, `flags[]` | pairs, lists | Age, active boosts, risk flags |
| `querySide` | pairs (`tokenPairs`) | `base` or `quote`: where the queried token sits in the pool |
| `imageUrl`, `websites[]`, `socials[]` | pairs | Token profile links (`includeInfo`) |
| `rank`, `listType`, `description`, `iconUrl`, `headerUrl`, `website`, `twitter`, `telegram`, `links[]`, `boostAmount`, `totalBoostAmount`, `adType`, `adDate`, `adDurationHours`, `adImpressions`, `claimDate`, `isCommunityTakeover`, `pairsFound`, `totalLiquidityUsd`, `topPairUrl` | lists | Promotion data + market summary |
| `slug`, `name`, `description`, `icon`, `tokenCount`, `marketCapChange1h`, `marketCapChange6h`, `marketCapChange24h` | metas | Narrative stats; `meta` pair items also carry `metaSlug`, `metaName` |
| `ordersCount`, `approvedCount`, `hasApprovedProfile`, `hasPaidAds`, `ordersByType`, `lastPaymentAt`, `orders[]` | orders | Paid DEX Screener products for the token |
| `fetchedAt` | all | When the item was fetched (ISO 8601 UTC) |

### Examples

**1. Find the real token behind a ticker (Ethereum, one pair per token, by volume)**

```json
{ "mode": "search", "queries": ["PEPE"], "chainId": "ethereum", "minLiquidityUsd": 50000, "onePairPerToken": true, "sortBy": "volume24h", "limitPerQuery": 5 }
```

**2. Monitor your pools every 15 minutes**

```json
{ "mode": "pairs", "chainId": "base", "pairAddresses": ["0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d"], "fields": ["priceUsd", "change1h", "liquidityUsd", "volume24h", "flags"] }
```

**3. New launches on Solana that people are paying to promote**

```json
{ "mode": "latestBoosts", "chainId": "solana", "minLiquidityUsd": 10000, "maxAgeHours": 72, "sortBy": "volume24h", "limitPerQuery": 30 }
```

**4. Due diligence: all USDC pools of a token + its paid promotion history**

```json
{ "mode": "tokenPairs", "chainId": "solana", "tokenAddresses": ["So11111111111111111111111111111111111111112"], "quoteSymbols": ["USDC"], "limitPerQuery": 20 }
```

```json
{ "mode": "orders", "chainId": "solana", "tokenAddresses": ["So11111111111111111111111111111111111111112"] }
```

**5. Narrative research: trending metas, then liquid pairs inside AI and x402**

```json
{ "mode": "metas", "limitPerQuery": 20 }
```

```json
{ "mode": "meta", "metaSlugs": ["ai", "x402"], "minLiquidityUsd": 20000, "limitPerQuery": 10 }
```

### Output

Pair item (trimmed real example from `mode: "tokens"`, AERO on Base):

```json
{
  "query": "0x940181a94A35A4569E4529A3CDfB74e38FD98631", "found": true,
  "id": "base:0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d", "chainId": "base", "dexId": "aerodrome", "labels": [],
  "pairAddress": "0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d", "url": "https://dexscreener.com/base/0x6cdcb1c4a4d1c3c6d054b27ac5b77e89eafb971d",
  "symbol": "AERO", "name": "Aerodrome", "tokenAddress": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
  "quoteSymbol": "USDC", "quoteAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "priceUsd": 0.5641, "priceNative": 0.5641, "change5m": null, "change1h": -0.15, "change6h": -0.17, "change24h": -2.45,
  "volume1h": 12864.49, "volume24h": 582264.35, "buys24h": 124, "sells24h": 1627, "txns24h": 1751, "buySellRatio24h": 0.08,
  "liquidityUsd": 33992284.21, "volumeToLiquidity24h": 0.0171, "fdv": 1116194418, "marketCap": 557850865,
  "pairCreatedAt": "2023-09-07T22:50:45.000Z", "ageHours": 26433.6, "boosts": 0,
  "websites": ["https://aerodrome.finance/docs"], "socials": [{ "type": "twitter", "url": "https://x.com/aerodromefi" }],
  "flags": ["sell_pressure"], "fetchedAt": "2026-09-13T08:25:17.755Z"
}
```

List item (trimmed real example from `mode: "boosted"` with market data):

```json
{
  "rank": 1, "found": true, "id": "solana:FLk6FKAN26m1FT4ucguwy3uHBMzLKcEu8KMTYD2Zpump", "listType": "boosted", "chainId": "solana",
  "tokenAddress": "FLk6FKAN26m1FT4ucguwy3uHBMzLKcEu8KMTYD2Zpump", "url": "https://dexscreener.com/solana/flk6fkan26m1ft4ucguwy3uhbmzlkceu8kmtyd2zpump",
  "website": "https://stunksol.fun", "twitter": "https://x.com/StunkSOL", "telegram": "https://t.me/stunkportal", "totalBoostAmount": 500,
  "symbol": "Stunk", "pairsFound": 1, "priceUsd": 0.00108, "liquidityUsd": 104927.51, "volume24h": 6771442.02, "marketCap": 1074060,
  "change1h": 12.25, "change24h": -48.34, "pairCreatedAt": "2026-09-11T18:12:37.000Z", "ageHours": 38.2, "fetchedAt": "2026-09-13T08:25:29.578Z"
}
```

Every field, with its type and meaning, is listed in Reference → Output fields and in the dataset schema.

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~dexscreener-tokens/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"search","queries":["AERO"],"chainId":"base","onePairPerToken":true}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/dexscreener-tokens').call({ mode: 'latestBoosts', chainId: 'solana', minLiquidityUsd: 10000 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(token)
run = client.actor("yadroo/dexscreener-tokens").call(run_input={"mode": "pairs", "chainId": "base", "pairAddresses": ["0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d"]})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to your MCP client (Claude, Cursor, …) and call the `yadroo/dexscreener-tokens` tool with the same JSON.

### Pricing

Pay per event: **$0.001 per run start + $0.002 per dataset item** (pair, token, meta or order summary). Store discounts apply to the item price: Bronze −10 % ($0.0018), Silver −20 % ($0.0016), Gold and above −30 % ($0.0014); the start event is the same on every plan, and platform usage is included. A default search (10 pairs) costs $0.021; monitoring 5 pairs every 15 minutes costs about $1.06 per day; a 30-token boost list costs $0.061. Cap spend with `limitPerQuery`, `maxItems`, `onePairPerToken` and your "Maximum cost per run": the run stops at that limit, keeps every item it saved and says so in the status (`Stopped at your spending limit: N rows delivered`). Queries with no match (or everything filtered out) and failed lookups are not dataset items and cost nothing.

### Limits & FAQ

- **Rate limits** — DEX Screener allows 300 requests/min on pair, token and search endpoints and 60/min on boosts, profiles, takeovers, ads, metas and orders. The actor spaces requests (≈4/s and ≈1/s) and retries 429/5xx with exponential backoff.
- **Freshness** — live API data, typically seconds to a minute behind the chain.
- **Search is capped** — DEX Screener returns at most 30 pairs per search query, ranked across all chains, and the search endpoint has no chain parameter. Plain `PEPE` returns 1 Ethereum pair out of 30. With a `chainId` the actor therefore widens the search by default (`expandChainSearch`): quote-variant searches plus `/token-pairs` for each matching token on that chain. `PEPE` on `ethereum` goes from 1 pair to ~50 pools of ~10 PEPE-named tokens. It is still not an exhaustive list of every token with that name on the chain: DEX Screener exposes no such endpoint, and `/token-pairs` returns at most 30 pools per token. If you know the contract, use `tokenPairs`.
- **Liquidity is reported by DEX Screener** — pools with mispriced quote assets can show absurd USD liquidity; watch `suspicious_liquidity` and prefer `onePairPerToken` with a `chainId`.
- **Errors** — Apify refuses an off-list `mode`, `sortBy` or `sortOrder` before the run starts. A missing required input or an unknown `fields` name stops the run at once with a message that names the field (only the start event is charged); a `chainId` that looks like a typo is named in the status, and fails the run with "did you mean" when nothing is found. Per-query problems never stop the run and are never charged: queries / addresses / slugs with no match or everything filtered out are listed in the `SUMMARY` record under `notFound`, failed lookups under `errors` (with the reason; in `tokens` and `pairs` a failed request fails its batch of up to 30 addresses), with `notFoundCount` / `errorCount`; the status message sums it up (`10 item(s) saved · 1 not found (see SUMMARY)`). Inputs the run did not reach because `maxItems`, your spending limit or the run timeout stopped it are counted in `notProcessed`. The run fails only if every input failed and nothing was saved.
- **Timeouts** — each request waits at most 20 s and is retried within the run's remaining time. Near the run timeout the actor stops starting new requests, keeps what it saved and ends successfully with `Stopped before the run timeout: N rows saved`.
- **Not financial advice.** Data © DEX Screener, used via their public API.
- **Roadmap** — price/liquidity change alerts between runs, holder data via [base-token-intel](https://apify.com/yadroo/base-token-intel).

***

Made by **Yadroo**. Siblings: [base-token-intel](https://apify.com/yadroo/base-token-intel) · [wallet-intel](https://apify.com/yadroo/wallet-intel) · [coingecko-markets](https://apify.com/yadroo/coingecko-markets) · [defillama-protocols](https://apify.com/yadroo/defillama-protocols) · [crypto-sentiment](https://apify.com/yadroo/crypto-sentiment)

# Actor input Schema

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

`search` = pairs matching text/address queries. `tokens` = the price and pools of each token address on one chain (batched, 30 per request); every row describes the queried token itself. `tokenPairs` = every pool that contains a token, on either side (more complete than `tokens`). `pairs` = specific pair/pool addresses (for monitoring; filters are not applied). `boosted` = tokens with the most active boosts. `latestBoosts` = newest boost purchases. `profiles` = newest token profiles. `profileUpdates` = recently updated profiles. `takeovers` = latest community takeovers (CTO). `ads` = latest paid ads. `metas` = trending narratives (AI, dog, x402…). `meta` = pairs inside given narratives. `orders` = paid DexScreener orders (profile, ads) for token addresses. Apify refuses any other value before the run starts.

## `queries` (type: `array`):

mode=search: token names, symbols, token or pair addresses, e.g. "AERO", "PEPE", "SOL/USDC", "0x…". DexScreener returns up to 30 pairs per query.

## `chainId` (type: `string`):

DexScreener chain id, e.g. solana, ethereum, bsc, base, arbitrum, polygon, optimism, avalanche, sui, ton, tron, hyperliquid, sonic, robinhood (full list in README). Letter case and the display names are accepted, and so are the aliases eth, sol, bnb, binance, arb, matic, op, avax, sei, hype, xrp (each reading is shown in the status message). An id not on the list is passed to DexScreener as typed, with a note in the status (DexScreener adds chains often); if it is one or two letters away from a known id (e.g. "etherum") and the run finds nothing, the run fails with "did you mean". Required for tokens, tokenPairs, pairs, orders; a filter for search, meta and the token lists; ignored by metas. Empty = all chains.

## `expandChainSearch` (type: `boolean`):

mode=search with a chainId: DexScreener search returns at most 30 pairs across ALL chains, so the chain filter alone often leaves 0–2 pairs (e.g. PEPE on ethereum → 1). When on, the actor also searches "<query>/\<chain's main quote assets>" (e.g. PEPE/WETH, PEPE/USDC) and pulls the pools of every matching token on that chain from /token-pairs. Costs a few extra requests per query (≈3–15 s). Off = plain search, filtered.

## `chainSearchTokens` (type: `integer`):

With "Widen search" on: how many matching tokens (most liquid first) get their pool list fetched from /token-pairs (up to 30 pools each). 0 = only the extra quote-variant searches.

## `tokenAddresses` (type: `array`):

mode=tokens / tokenPairs / orders: token contract (mint) addresses on `chainId`. Any number — batched 30 per request in mode=tokens. In mode=tokens each row is the queried token's own pool (it is the base token); when DexScreener lists it only as the quote token of its pools, those pools are turned around (its own USD price = base price / native price) and flagged `price_from_quote_side`.

## `pairAddresses` (type: `array`):

mode=pairs: pool/pair addresses on `chainId` (from a previous run's `pairAddress`).

## `metaSlugs` (type: `array`):

mode=meta: narrative slugs such as ai, dog, cat, x402, trump, nft, degen (run mode=metas for the live list).

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

Skip pairs with less liquidity (in list modes: tokens whose most liquid pair has less). Set 0 to keep pairs/tokens without liquidity data, e.g. bonding-curve launchpads or tokens with no pool yet.

## `maxLiquidityUsd` (type: `integer`):

Skip pairs with more liquidity (find small caps).

## `minVolume24hUsd` (type: `integer`):

Skip pairs with less 24h trading volume.

## `minMarketCapUsd` (type: `integer`):

Uses market cap, or FDV when market cap is missing.

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

Skip pairs above this market cap (or FDV when market cap is missing).

## `minTxns24h` (type: `integer`):

Buys + sells in the last 24 h.

## `minPriceChange24h` (type: `integer`):

e.g. 20 = only pairs up at least 20 %; -100 allowed.

## `maxPriceChange24h` (type: `integer`):

e.g. -20 = only pairs down at least 20 %.

## `minAgeHours` (type: `integer`):

Skip pairs younger than this (avoid brand-new launches).

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

e.g. 24 = only pairs created in the last day (new launches).

## `dexIds` (type: `array`):

Keep only these DEXes, e.g. uniswap, aerodrome, raydium, pumpswap, meteora, orca, pancakeswap, sushiswap, quickswap, camelot, traderjoe. Empty = all.

## `quoteSymbols` (type: `array`):

Keep only pairs quoted in these assets, e.g. USDC, USDT, WETH, SOL, WBNB. Empty = all.

## `sortBy` (type: `string`):

Sort order of results within each query / list (nulls last). `pairAge` + asc = newest first.

## `sortOrder` (type: `string`):

`desc` = largest first, `asc` = smallest first.

## `onePairPerToken` (type: `boolean`):

Collapse multiple pools of the same token to its most liquid pair (cleaner token lists, fewer items).

## `limitPerQuery` (type: `integer`):

Maximum pairs per query/token/meta, or tokens per list mode.

## `maxItems` (type: `integer`):

Hard cap on dataset items for the whole run (cost control). The run also stops at your "Maximum cost per run" and says so in the status.

## `includeMarketData` (type: `boolean`):

boosted / latestBoosts / profiles / profileUpdates / takeovers / ads: attach price, liquidity, volume, market cap and age of each token's most liquid pair (1 extra request per 30 tokens).

## `includeInfo` (type: `boolean`):

Attach `imageUrl`, `websites`, `socials` to pair items.

## `newPairHours` (type: `integer`):

Pairs younger than this get flag `new_pair_<N>h`.

## `fields` (type: `array`):

Keep only these top-level fields, in this order. id, query, chainId, found, url, fetchedAt are always kept (first, unless you list them). Letter case is forgiven; an unknown name stops the run with a suggestion before any row is charged, and so does a list with no field this mode's rows have. Field names: README → Reference → Output fields. Example: \["symbol", "priceUsd", "liquidityUsd", "volume24h", "change24h"]. Empty = full item.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "AERO"
  ],
  "expandChainSearch": true,
  "chainSearchTokens": 10,
  "minLiquidityUsd": 1000,
  "sortBy": "liquidity",
  "sortOrder": "desc",
  "onePairPerToken": false,
  "limitPerQuery": 10,
  "maxItems": 100,
  "includeMarketData": true,
  "includeInfo": true,
  "newPairHours": 24
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "queries": [
        "AERO"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/dexscreener-tokens").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 = { "queries": ["AERO"] }

# Run the Actor and wait for it to finish
run = client.actor("yadroo/dexscreener-tokens").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 '{
  "queries": [
    "AERO"
  ]
}' |
apify call yadroo/dexscreener-tokens --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/dexscreener-tokens"
        }
    }
}
```

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/TTSJ1kaR4hEt4lQmL/builds/5clNSXw9d0OrjhHUG/openapi.json