DexScreener Scraper: DEX Pairs, Liquidity & Volume

DexScreener Pairs Scraper returns one structured record per decentralised-exchange pool, price in USD and in the native quote token, pooled liquidity, 24-hour volume, buy/sell transaction counts, 24-hour price change, FDV, market cap, pool creation time and the DexScreener link, across Ethereum, Solana, Base, BSC, Arbitrum and every other chain DexScreener indexes.

DexScreener publishes this data for programmatic use, so the Actor needs nothing configured to reach it: no browser, no proxy, no key.

Agent skill: SKILL.md

https://api.apify.com/v2/key-value-stores/t7YoTxpZEJOWvw4Ug/records/dexscreener-pairs-scraper.md

What you get

Output field	Meaning
chainId, dexId	Chain slug (ethereum, solana) and the DEX the pool lives on (uniswap, orca)
pairAddress	The pool contract address
pairSymbol	WETH/SOL style shorthand, handy for tables and joins
baseToken, quoteToken	{ address, name, symbol } for both sides
priceUsd, priceNative	Base-token price in USD and denominated in the quote token
liquidityUsd	Total pooled liquidity in USD
volume24h	24-hour traded volume in USD
priceChange24h	24-hour price change, in percent
txns24hBuys, txns24hSells	Buy and sell counts over 24 hours, the buy/sell skew is the cheapest sentiment signal on chain
fdv, marketCap	Fully diluted valuation and market cap in USD
pairCreatedAt	Pool creation time as ISO-8601
url	DexScreener page for the pair
scrapedAt	Run timestamp

A RUN_SUMMARY record in the key-value store holds per-run counts, the filters used, and any request that failed or matched nothing.

Common use cases

Monitor new token launches, search a symbol and keep only pools with real depth, so honeypots and abandoned pools never reach your dataset.

{
 "searchQueries": ["PEPE", "WIF", "BONK"],
 "minLiquidityUsd": 50000,
 "maxResults": 200
}

Track liquidity migration between DEXes, the same token across chains and venues, on a schedule. Diff liquidityUsd per dexId between runs and you can see depth move.

{
 "searchQueries": ["USDC"],
 "chains": ["ethereum", "base", "arbitrum"],
 "minLiquidityUsd": 250000
}

Screen for volume anomalies, watch a fixed shortlist of pools and alert when volume24h divided by liquidityUsd spikes, or when txns24hBuys overwhelms txns24hSells.

{
 "pairAddresses": [
 "ethereum:0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
 "solana:HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF"
 ]
}

Quick start

Everything DexScreener has for one symbol:

{
 "searchQueries": ["WETH"]
}

Deep pools on major chains only:

{
 "searchQueries": ["WETH", "USDC"],
 "chains": ["ethereum", "solana", "base"],
 "minLiquidityUsd": 100000,
 "maxResults": 100
}

Input

At least one of searchQueries or pairAddresses is required.

Field	Type	Default	Notes
searchQueries	array	[]	Symbols, token names or contract addresses. One request each; up to 30 pairs come back per query, across all chains.
pairAddresses	array	[]	Pool addresses. ethereum:0x88e6… or a pasted DexScreener URL is a direct lookup; a bare address falls back to search.
chains	array	[]	Keep only these chain slugs. Applied after the request, since search is chain-agnostic.
minLiquidityUsd	integer	0	Drop pools thinner than this.
maxResults	integer	500	Total cap across all requests. 0 = no limit.

Which combinations make sense. searchQueries is for discovery. You do not know the pools yet, and you want whatever the symbol turns up. pairAddresses is for monitoring. You already know the pools and want exactly those, every run, in a stable shape. Combining both is fine; results are de-duplicated on chainId + pairAddress.

chains and minLiquidityUsd are the filters that make a search result usable: a bare symbol search returns pools on 15 different chains, most of them dust. chains does nothing useful alongside chain-qualified pairAddresses, those are already exact.

maxResults is consumed in request order (searches first, then address lookups), so put the query you care most about first.

Output example

{
 "chainId": "solana",
 "dexId": "orca",
 "pairAddress": "HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF",
 "pairSymbol": "WETH/SOL",
 "baseToken": {
 "address": "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs",
 "name": "Wrapped Ether (Wormhole)",
 "symbol": "WETH"
 },
 "quoteToken": {
 "address": "So11111111111111111111111111111111111111112",
 "name": "Wrapped SOL",
 "symbol": "SOL"
 },
 "priceUsd": 1907.6,
 "priceNative": 25.9643,
 "liquidityUsd": 3934516.33,
 "volume24h": 2885291.23,
 "priceChange24h": 2.02,
 "txns24hBuys": 4668,
 "txns24hSells": 3268,
 "fdv": 166094986,
 "marketCap": 166094986,
 "pairCreatedAt": "2022-11-28T02:25:41.000Z",
 "url": "https://dexscreener.com/solana/hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef",
 "scrapedAt": "2026-08-06T11:37:40.563Z"
}

RUN_SUMMARY looks like this:

{
 "requestsIssued": 4,
 "requestsFailed": 0,
 "failures": [],
 "pairsSaved": 10,
 "filters": {
 "searchQueries": ["WETH"],
 "pairAddresses": ["ethereum:0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640"],
 "chains": ["ethereum", "solana", "base"],
 "minLiquidityUsd": 100000,
 "maxResults": 12
 },
 "finishedAt": "2026-08-06T11:37:46.409Z"
}

Finding a chain slug or pair address

Open any pool on DexScreener and read the URL:

https://dexscreener.com/solana/HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF
 └ chain ┘ └────────────── pair address ──────────────┘

Pass it as solana:HktfL7iw…, or just paste the whole URL, the Actor pulls both parts out itself. Common chain slugs: ethereum, solana, base, bsc, arbitrum, polygon, avalanche, optimism, sui, ton.

Limits and behaviour

• Requests are throttled on purpose. DexScreener documents 300 requests per minute for the search and pairs endpoints. This Actor leaves 220 ms between every request, roughly 270/min, so a long run never trips the limit. A 429 that does slip through is retried with a longer backoff than an ordinary network error.
• Address lookups are batched. Chain-qualified addresses are grouped by chain and sent 30 at a time to /latest/dex/pairs/{chain}/{a,b,c}, so 300 monitored pools on one chain cost 10 requests, not 300.
• A bare address costs the same but is less precise. Without a chain prefix the address goes through /search, which can return more than one match. Prefix it when you know the chain.
• Prices arrive as strings. DexScreener sends priceUsd and priceNative as decimal strings so sub-cent tokens do not lose precision in transit. They are cast to numbers here so the dataset sorts and filters numerically.
• pairCreatedAt is not always present. Roughly one pool in six has no creation timestamp in the API; the field is null rather than guessed.
• Search is a snapshot, not a full index. One query returns up to 30 pairs. To go wider, pass more specific queries (a contract address rather than a symbol) instead of expecting deeper pagination, the endpoint does not offer any.
• One failed request never kills the run. It is recorded in RUN_SUMMARY.failures and the Actor continues; it only throws when every request failed.
• Public market data only. No wallets, no keys, no signing, no private endpoints.

API example

curl -X POST "https://api.apify.com/v2/acts/arman-bd~dexscreener-pairs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{
 "searchQueries": ["WETH", "USDC"],
 "chains": ["ethereum", "solana"],
 "minLiquidityUsd": 100000,
 "maxResults": 50
 }'

JavaScript example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('arman-bd/dexscreener-pairs-scraper').call({
 searchQueries: ['WETH'],
 chains: ['ethereum', 'base'],
 minLiquidityUsd: 250000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) {
 const turnover = (p.volume24h / p.liquidityUsd).toFixed(2);
 console.log(`${p.pairSymbol}\t${p.dexId}\t$${p.priceUsd}\tturnover ${turnover}x`);
}

Defaults: 1 GB memory, 10 minute timeout.

FAQ

Do I need a proxy? No. Proxy configuration is not required to run this Actor.

Do I need a DexScreener account or API key? No. You supply no credentials.

What happens if a source is unavailable? It is logged, recorded in RUN_SUMMARY.failures, and the run continues with the remaining requests. The Actor only errors out when every request fails.

Can I schedule it? Yes, it is built for it. Pin a list of pairAddresses and run every few minutes; the throttle keeps you comfortably inside DexScreener's limits.

Why did a pair address return nothing? Either the chain prefix is wrong, or the pool is not indexed by DexScreener. Address batches that return nothing are recorded in RUN_SUMMARY.failures with the chain named, which tells the two apart.

Is the data real-time? DexScreener serves it with a short cache, around 30 seconds. Polling faster than that returns the same numbers and just spends your rate budget.

Why do fdv and marketCap often match? For tokens with no locked or unvested supply they are the same figure. DexScreener reports both, and this Actor passes both through unchanged.

Can I integrate it with something else? Yes, Apify API, client libraries, webhooks, scheduled runs, dataset exports (JSON/CSV/Excel) or MCP. Output is structured JSON.