Dexscreener Scraper

On-chain tokens have no ticker and no exchange listing, so the only way to price one is to find its liquidity pool. This Actor searches Dexscreener by token address, pair address or name, and returns one structured record per pair: price in USD and in the quote token, pooled liquidity, 24h volume, buy and sell counts and fully diluted valuation, on whichever chain and DEX the pair actually lives.

What it does

• Searches by token contract address, pair address or free text, so you can start from whatever you have.
• Returns one record per pair, and a token that trades in several pools returns each of them, ranked by liquidity, so you can pick the real market rather than the first hit.
• Covers every chain Dexscreener indexes, with chainId and dexId on each record so you always know where a price came from.
• Carries buy and sell transaction counts next to volume, which is how you tell organic flow from a single large trade.
• Reports pooled liquidity in USD, the number that tells you whether a price can be traded at size.
• Needs no API key and no wallet.

Use cases

You need to	How this Actor does it
Price a token with no exchange listing	Search the contract address and read value from its deepest pool
Check whether a price is tradeable	Read liquidityUsd before you trust value
Spot one-sided flow	Compare buys24h against sells24h
Find every pool for a token	Search the token address and raise Pairs per query
Watch a new listing	Schedule the run against the pair address and chart liquidity and volume
Feed an on-chain research agent	Call the Actor over MCP and let the model pass the address it found

Quick start

1. Click Try for free.
2. Add what you want to search, one per line: a token contract address, a pair address, or a name like PEPE. Addresses give the most precise results.
3. Set Pairs per query to control how many pools each search returns.
4. Click Start. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

Input

Field	Type	Default	What it controls
queries	array	a USDC contract address	Token addresses, pair addresses or free text to search
pairsPerQuery	integer	10	How many pairs each query returns, ranked by liquidity
maxItems	integer	0	Caps how many records are written. 0 writes them all

{
    "queries": [
        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "PEPE"
    ],
    "pairsPerQuery": 10,
    "maxItems": 0
}

Output

One dataset item per pair. A query that matched nothing comes back with status: "failed" and the query in requested, so you can tell an empty search from a missing record.

Field group	Fields
Identity	status, requested, chainId, dexId, pairSymbol, pairAddress, url
Tokens	baseTokenSymbol, baseTokenName, baseTokenAddress, quoteTokenSymbol
Price	value, priceQuote, priceChange1h, priceChange6h, priceChange24h
Market	liquidityUsd, volume24h, fdv, marketCap
Flow	buys24h, sells24h
Timing	pairCreatedAt, validFrom, scrapedAt

{
    "status": "ok",
    "requested": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "chainId": "ethereum",
    "dexId": "uniswap",
    "pairSymbol": "USDC/WETH",
    "baseTokenSymbol": "USDC",
    "quoteTokenSymbol": "WETH",
    "value": 1.0002,
    "priceChange24h": 0.01,
    "liquidityUsd": 41882199.4,
    "volume24h": 128441002.7,
    "buys24h": 8214,
    "sells24h": 7702,
    "fdv": 61220118844,
    "validFrom": "2026-09-04T20:00:01.000Z",
    "url": "https://dexscreener.com/ethereum/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640"
}

Integrations

Run it over the API and get the rows back in one call:

curl -X POST "https://api.apify.com/v2/acts/publicmoney~dexscreener-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE"], "pairsPerQuery": 10, "maxItems": 0}'

From Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/dexscreener-scraper").call(run_input={"queries": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "PEPE"], "pairsPerQuery": 10, "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["value"], item["validFrom"])

Give an AI agent the Actor over MCP:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/dexscreener-scraper"
        }
    }
}

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

Cost

Pay per event, so you pay for records rather than compute time.

Event	Free tier	Top volume tier
Record with data	$0.002	$0.0007
Actor start	$0.00005 per GB	Same

A record that returned no data is published as a failure row and is never charged. Six volume tiers apply, so the per-record price falls with monthly volume.

Troubleshooting

Issue	Solution
A query returns failed	Dexscreener indexes no pair for it. Check the address is the token or pair address and not a wallet.
I get several rows for one token	By design. A token trades in several pools and each is a separate market. Rows come ranked by liquidity, so the first is usually the real one.
The price looks nothing like the exchange price	Check liquidityUsd. A pool with little liquidity prices at whatever the last trade was and cannot be traded at size.
marketCap is missing but fdv is there	Dexscreener publishes market cap only when it knows the circulating supply. FDV needs only the total supply.
A free-text query returns the wrong token	Names are not unique on-chain and impostor tokens are common. Search the contract address instead.

FAQ

Is the Dexscreener API free?

Dexscreener publishes a public API with a rate limit and no key. This Actor reads it, so there is nothing to register, and the Actor is charged per record.

Can I look a token up by contract address?

Yes, and it is the reliable way to do it. Names collide on-chain and impostor tokens are common, so the address is the only unambiguous input.

Which chains does it cover?

Every chain Dexscreener indexes. Each record carries chainId and dexId, so you always know which chain and which DEX a price came from rather than assuming.

Why does one token return several prices?

Because it trades in several pools, and each pool is its own market with its own price and liquidity. Read liquidityUsd to find the one that matters.

Does it return historical prices?

No series, but each record carries price change over 1h, 6h and 24h. To build a series, schedule the Actor against a pair address.

Do I need a Dexscreener API key?

No. You need an Apify token to call the Actor over the API. No Dexscreener credential is involved anywhere.

Can I get this data in Python?

Yes, with the apify-client package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

Is it legal to scrape Dexscreener?

This Actor reads public Dexscreener data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

Changelog

• 0.0.2 Added buy and sell counts, FDV and the multi-window price change.
• 0.0.1 First release. Pair search by address or text across every indexed chain.

Feedback

Found a field Dexscreener publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.