# Dexscreener Scraper (`publicmoney/dexscreener-scraper`) Actor

Extract Dexscreener DEX pair data across every chain it indexes: price in USD and in the quote token, pooled liquidity, 24h volume, buy and sell counts and FDV, by token or pair address. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/dexscreener-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

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?

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

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 |

```json
{
    "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` |

```json
{
    "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:

```bash
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:

```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:

```json
{
    "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.

# Actor input Schema

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

What to search for, one per line: a token contract address, a pair address, or free text such as a token name. Addresses are the reliable input because names collide on-chain and impostor tokens are common. Examples: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 'PEPE'. Default is '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'.

## `pairsPerQuery` (type: `integer`):

How many pairs each query returns, ranked by pooled liquidity so the deepest market comes first. A token that trades in several pools returns one record per pool. Examples: 1, 10, 30. Default is 10.

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

Maximum number of pairs to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every pair given.

## Actor input object example

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

# Actor output Schema

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

One item per requested input, in the default dataset.

# 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": [
        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
    ],
    "pairsPerQuery": 10,
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/dexscreener-scraper").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": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"],
    "pairsPerQuery": 10,
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/dexscreener-scraper").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": [
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
  ],
  "pairsPerQuery": 10,
  "maxItems": 0
}' |
apify call publicmoney/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/zAespfzD3zUQUVNiI/builds/yCN7a5hWrdoNoilGK/openapi.json