# DexScreener Scraper: DEX Pairs, Liquidity & Volume (`arman-bd/dexscreener-pairs-scraper`) Actor

Scrape DexScreener for decentralised-exchange pairs: price, liquidity, 24h volume, transaction counts, FDV and price changes across Ethereum, Solana, Base and more.

- **URL**: https://apify.com/arman-bd/dexscreener-pairs-scraper.md
- **Developed by:** [Arman Hossain](https://apify.com/arman-bd) (community)
- **Categories:** Business, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.37 / 1,000 pair scrapeds

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/platform/actors/running/actors-in-store#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

## DexScreener Scraper: DEX Pairs, Liquidity & Volume

![DexScreener Scraper: DEX pairs by symbol or address, price, liquidity, 24h volume, buy/sell counts and FDV](https://api.apify.com/v2/key-value-stores/ZQOcNAOHrIgTacAmy/records/dexscreener-pairs-scraper.jpg)

**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)**

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

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

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

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

### Quick start

Everything DexScreener has for one symbol:

```json
{
 "searchQueries": ["WETH"]
}
```

Deep pools on major chains only:

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

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

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

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

```js
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.

# Actor input Schema

## `searchQueries` (type: `array`):

Token symbols ('WETH'), token names ('Wrapped Ether'), contract addresses, or a 'SOL/USDC' style pair. Each query is one request and returns up to 30 matching pairs across every chain.

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

Specific pool addresses. Prefix with the chain for a direct lookup. 'ethereum:0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640'. A pasted DexScreener pair URL works too. A bare address with no chain is resolved through search instead, which costs the same but is slightly slower.

## `chains` (type: `array`):

Keep only pairs on these chains. Use DexScreener's own chain slugs, visible in any pair URL. 'ethereum', 'solana', 'base', 'bsc', 'arbitrum', 'polygon'. Leave empty for every chain.

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

Drop pairs with less pooled liquidity than this. 50000 filters out most abandoned and honeypot pools while keeping real markets. Set 0 to keep everything.

## `maxResults` (type: `integer`):

Cap the total number of pairs saved across every query. Set 0 to keep everything the API returns.

## Actor input object example

```json
{
  "searchQueries": [
    "SOL",
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
  ],
  "pairAddresses": [
    "ethereum:0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
    "https://dexscreener.com/solana/HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF"
  ],
  "chains": [
    "ethereum",
    "solana",
    "base"
  ],
  "minLiquidityUsd": 50000,
  "maxResults": 500
}
```

# Actor output Schema

## `items` (type: `string`):

Every record the run produced.

## `runsummary` (type: `string`):

The RUN\_SUMMARY record from the run's key-value store.

# 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 = {
    "searchQueries": [
        "WETH",
        "USDC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arman-bd/dexscreener-pairs-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 = { "searchQueries": [
        "WETH",
        "USDC",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arman-bd/dexscreener-pairs-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 '{
  "searchQueries": [
    "WETH",
    "USDC"
  ]
}' |
apify call arman-bd/dexscreener-pairs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arman-bd/dexscreener-pairs-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/vtvetRKk9CqmJ1ktI/builds/wt2utKSf2wopHDGAf/openapi.json