DexScreener Pairs Scraper

Returns: one row per trading pair with chainId, dexId, pairAddress, baseTokenSymbol, priceUsd, liquidityUsd, and volume24h. Input: {"searchQueries":["WETH"],"maxItems":10} Best for: token pool lookups, pair comparisons, and scheduled market snapshots.

{"id":"solana:hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef","chainId":"solana","dexId":"orca","baseTokenSymbol":"WETH","priceUsd":2503.79,"liquidityUsd":7174833.03,"volume24h":3620702.25}

What does DexScreener Pairs Scraper do?

DexScreener Pairs Scraper extracts public trading pair data from the DexScreener JSON API. Give it a token symbol or name, a token address, or a pair URL. It returns one dataset item for each distinct trading pair. You can also select a public discovery list to find current token profiles, boosts, or community takeovers and then collect the associated pairs. No login is required.

The Actor is useful when you need a structured snapshot of pools across chains. A search for a ticker can return pairs for unrelated tokens that share that ticker, so the output keeps the chain, token addresses, exchange identifier, and pair address alongside market figures. You can restrict chains or set minimum liquidity and daily volume to narrow the result. The Actor does not decide which token is authentic, recommend a trade, or track subsequent changes after the run.

It calls the API directly and does not open the DexScreener website. The values are a snapshot at collection time; prices, volume, and liquidity can change quickly. Each result includes its collection timestamp so downstream systems can judge how recent the data is. This Actor is independently built and is not affiliated with DexScreener.

What data can you get?

Each row represents one pair. The default overview shows the token, chain, exchange, price, liquidity, daily volume, daily price change, valuation, age, and pair URL. The complete dataset has more columns. Optional fields are null when the API omits them, while arrays such as labels and websites can be empty. Numeric prices are converted from the API's string values to numbers; absent values are never converted to zero.

Field	Meaning
id, sourceUrl, pairUrl	Stable chain and pair identifier and the public pair URL
chainId, dexId, pairAddress	Blockchain, exchange, and pool address
baseTokenAddress, baseTokenName, baseTokenSymbol	Base asset identity
quoteTokenAddress, quoteTokenName, quoteTokenSymbol	Quote asset identity
priceUsd, priceNative	Base asset price in USD and quote currency
liquidityUsd, liquidityBase, liquidityQuote	Pool liquidity in USD and token amounts
fdv, marketCap	Fully diluted valuation and reported market capitalization
volume24h, volume6h, volume1h, volume5m	Volume for four rolling windows
priceChange24h, priceChange6h, priceChange1h, priceChange5m	Percent price changes for those windows
buys24h, sells24h, txns	Daily buy and sell counts and the API's windowed counts
pairCreatedAt, pairAgeHours	Pair creation time and approximate age when collected
labels, boostsActive, boostTotalAmount	Pool labels and available boost data
imageUrl, headerImageUrl, websites, socials	Optional token profile media and links
twitter, telegram, discord	First matching social link of each type, when supplied
tokenDescription	Optional description from a discovery entry
inputSource, scrapedAt	Input that found the pair and collection time

id is built from the chain and normalized pair address. The Actor removes duplicate IDs across all supplied inputs. The same pool found through a search and a pair URL appears once. Profile links, images, and descriptions are only present when the upstream response supplies them. The Actor copies those values without visiting their destinations. Trading counts and changes may be absent for quiet pools or short-lived pairs.

How to use

Enter one or more search queries to find pairs by token name, ticker, pair name, or address. Search is broad: a ticker may match many different assets. For a known contract, provide a chain-qualified token address so the Actor requests that token's pools. For a known pool, provide its DexScreener URL or chainId/pairAddress. A DexScreener search URL with a q parameter can be supplied in startUrls and is treated as a search query.

You can combine input methods. The Actor gathers pair responses, filters them, removes duplicates, applies a per-token pool cap if requested, optionally sorts the remaining records, and then applies maxItems. Results are charged only when written to the dataset. The API has no pagination for these endpoints: a single search or token request returns up to 30 pairs. Add more queries or addresses to cover more pools. Pair-address lookups are batched by chain, with up to 30 addresses per API call.

Use chainIds when a ticker exists on several networks and dexIds to select exchanges. Liquidity, 24-hour volume, FDV, market cap, and pair-age thresholds narrow the returned pairs; a positive threshold excludes pairs without that metric. Set maxPairsPerToken to 1 to retain the most liquid pool for each base token on each chain. With sortBy: "none", records follow API and input order, and fetching stops when maxItems unique matches are found. Sorted or per-token-capped runs collect all requested responses before selecting output. A failed individual request is recorded in the run summary, and other inputs can still produce results.

Input

The Console form groups lookup fields, filters, and advanced settings. At least one lookup or a discovery mode is useful. If every lookup is empty and discovery is none, the Actor warns and searches WETH so an empty API input still produces a usable sample. This fallback is meant for an initial run; specify your own target for repeatable work.

Input	Description and default
searchQueries	Text searches; Console prefill is WETH. Each term can return up to 30 pairs.
tokenAddresses	Token contracts as chainId:address, chainId/address, a DexScreener token URL, or a bare address.
pairUrls	Pair URLs or chainId/pairAddress strings. The runtime also accepts URL objects.
startUrls	Legacy URL-object list with a url property; the runtime also accepts strings. Search URLs with q are supported.
defaultChainId	Chain to use for a bare token address. Without it, the Actor searches the address and checks an exact token-address match.
discover	none, latestProfiles, latestBoosts, topBoosts, or communityTakeovers; default none.
chainIds	Optional chain filter; empty means any chain.
dexIds	Optional DEX identifier filter; empty means any DEX.
minLiquidityUsd	Minimum liquidity in USD; default 0.
maxLiquidityUsd	Maximum liquidity in USD; 0 disables the filter.
minVolume24hUsd	Minimum daily volume in USD; default 0.
minMarketCapUsd, maxMarketCapUsd	Inclusive reported market-cap bounds in USD; 0 disables either bound.
minPairAgeHours, maxPairAgeHours	Inclusive pair-age bounds in hours; 0 disables either bound.
maxPairsPerToken	Most liquid pools retained per base token; 0 keeps all, and is the default.
minFdvUsd, maxFdvUsd	Inclusive FDV bounds; 0 disables each. Missing FDV fails an enabled bound.
sortBy	none, liquidityUsd, volume24h, priceChange24h, pairCreatedAt, fdv, marketCap, or boostsActive; default none.
maxItems	Maximum distinct output rows, from 1 to 5000; default 50. The Console prefill is 10.
proxyConfiguration	Optional Apify Proxy configuration; disabled by default.

Here is an input for pools matching two tickers on Solana, with minimum liquidity and a strict result limit:

{
  "searchQueries": ["BONK", "WIF"],
  "chainIds": ["solana"],
  "minLiquidityUsd": 10000,
  "sortBy": "liquidityUsd",
  "maxItems": 20
}

For a known token, {"tokenAddresses":["solana:JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"],"maxItems":7} requests its pools and returns no more than seven rows. For a known pair, a pairUrls string can contain the full public pair URL. If a supplied pair address is actually a token address, the Actor tries the token-pairs endpoint as a fallback. Malformed entries are skipped with a warning. An unknown chain or dead search term does not create an error row.

Output

A local run with the WETH prefill produced the item below. Market values reflect that run and are examples of structure, not current quotes. The live dataset contains additional optional columns described above. The sourceUrl and pairUrl values refer to the public pair page, while inputSource identifies which input found it.

{
  "id": "solana:hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef",
  "sourceUrl": "https://dexscreener.com/solana/hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef",
  "chainId": "solana",
  "dexId": "orca",
  "pairAddress": "HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF",
  "baseTokenName": "Wrapped Ether (Wormhole)",
  "baseTokenSymbol": "WETH",
  "quoteTokenSymbol": "SOL",
  "priceUsd": 2503.79,
  "liquidityUsd": 7174833.03,
  "volume24h": 3620702.25,
  "priceChange24h": -0.08,
  "pairCreatedAt": "2022-11-28T02:25:41.000Z",
  "inputSource": "search:WETH",
  "scrapedAt": "2026-10-11T15:34:08.502Z"
}

The default dataset is the main output. The key-value store also contains RUN_SUMMARY, with the number of API inputs processed, pairs found before filtering, rows pushed, and request errors. When a lookup has no matches, the run succeeds with an empty dataset, logs a warning, and sets a status message naming the inputs and what to change. If the API returned pairs but filters removed them, relax chainIds, dexIds or numeric bounds. If no pairs were found, check the chain and contract or pair address, or try another token symbol. Request failures also direct you to RUN_SUMMARY.errors; retry later or enable Apify Proxy for persistent IP blocks. A hidden verification input saves evidence to SNAPSHOTS for the first ten rows. API fields retain the raw pair object; inputSource retains the lookup label derived from the input, and scrapedAt retains the Actor's collection timestamp. Those two values are Actor metadata rather than DexScreener API fields. Snapshots are for source auditing rather than normal integration output.

How much does it cost?

The Actor is charged per result written to the dataset. A lookup that produces zero rows does not generate result events, and a limit of seven can charge for at most seven results. The number of upstream API responses may be larger than the output count because filtering, deduplication, sorting, and maxItems are applied before records are pushed. Consult the Actor's Pricing tab for the current charge information and billing terms. No separate enrichment step is used.

Use with AI agents (MCP)

An AI agent can use the Actor through Apify MCP to request structured pair data. Configure the MCP server for this Store path:

https://mcp.apify.com/?tools=axiomworks/dexscreener-pairs-scraper

Ask for a precise target and a bounded result count. For example, an agent can request: “Find up to seven Solana pairs matching WIF, sorted by liquidity, and include their pair addresses and 24-hour volume.” Another prompt can be: “Look up the pools for this chain-qualified token contract and return the most liquid pool with its source URL.” The response is suitable for comparison or monitoring workflows, but the agent should account for the data's collection time and should not treat matching symbols alone as identity proof.

The first input fields exposed to agents are the lookup fields, followed by filters and the item limit. Required values can be sent explicitly in the tool call. If an agent supplies no target, the Actor uses its documented WETH sample fallback. A narrow chain filter and an address are more reliable when a symbol is shared by multiple tokens. The id field lets an agent merge repeated runs without treating the same pair as a new asset.

Integrations and API

Use the dataset URL from a completed run to import rows into a spreadsheet, database, alerting workflow, or another Actor. The Apify API can start a run and return its dataset items. Replace APIFY_TOKEN in the following examples with your own authenticated client configuration; keep tokens in your secret manager. The examples use a bounded search to keep the response predictable.

Python with the Apify client:

import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/dexscreener-pairs-scraper").call(
    run_input={"searchQueries": ["WETH"], "maxItems": 7}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["id"], item.get("liquidityUsd"))

JavaScript with the Apify client:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/dexscreener-pairs-scraper').call({
    searchQueries: ['WETH'], maxItems: 7,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) process.stdout.write(`${item.id}\n`);

A cURL request to the synchronous dataset endpoint:

curl -X POST \
  'https://api.apify.com/v2/acts/axiomworks~dexscreener-pairs-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"searchQueries":["WETH"],"maxItems":7}'

For repeated use, store the token outside scripts and use your environment or platform secret settings. The dataset may contain several pools with the same base symbol. Match by chain and contract address when joining to other records. If you want a stable sample size across runs, remember that an endpoint can return fewer than the requested maximum after filters or because fewer matching pools exist.

FAQ

Why do I see unrelated tokens for a symbol? Search matches public names and tickers across chains. A symbol is not a unique asset identifier. Inspect baseTokenAddress, quoteTokenAddress, chainId, and pairAddress, or use a known contract address as input.

Why did my query produce fewer rows than maxItems? The API may return fewer than 30 pairs for one search, and filtering or deduplication can reduce that count. Add another query or address to broaden coverage. maxItems is a ceiling, not a minimum.

Can I request every pair on DexScreener? The documented lookup endpoints have no page cursor. Search and token calls are capped by the upstream response. This Actor combines multiple inputs, but it cannot enumerate all pairs from a single query.

Why are profile fields empty? Image, website, social, and discovery description fields depend on upstream token profile data. Pools without that data have empty or null values. The Actor does not guess missing links.

What happens when the API rate limits a request? The Actor retries block and server responses with delays. If a request still fails, it logs the failure and records it in RUN_SUMMARY; other inputs continue. Users who need another exit IP can configure Apify Proxy in advanced input.

Is the output historical? No. Market metrics are the API's current snapshot at request time. pairCreatedAt describes the pair's creation, while scrapedAt describes when this run collected the row. Store successive run outputs yourself if you need a time series.

Is it legal to scrape DexScreener?

The Actor reads public JSON API responses and does not access an account, private data, or protected pages. Whether a particular use is lawful depends on your location, the data, and how you use the output. Review the applicable terms and rules for your use case, keep requests modest, and respect people whose information appears in optional profile links. The Actor does not imply endorsement or affiliation with DexScreener. It does not execute URLs found in token profiles or contact their destination hosts.

Feedback

If a pair lookup returns an unexpected pool, include the input, the chain and pair address, the run status, and the RUN_SUMMARY error list when reporting it through the Actor's Store feedback channel. Avoid posting API tokens or other secrets. Concrete examples help distinguish a parsing issue from an upstream change or a shared ticker. For missing market fields, compare the pair's public API response with the output at the same collection time, since market data changes rapidly. Feature requests are most useful when they describe the exact input and output field needed.