# DexScreener Scraper (`crawlerbros/dexscreener-scraper`) Actor

Scrape DexScreener with real-time DEX token and trading pair data across 20+ blockchains. Search tokens, fetch pair details, trending/boosted tokens, and token profiles. No auth required.

- **URL**: https://apify.com/crawlerbros/dexscreener-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Scrape real-time DEX trading pair data from [DexScreener](https://dexscreener.com) — the leading platform for tracking decentralized exchange tokens and pairs across 20+ blockchains including Ethereum, BSC, Solana, Arbitrum, Base, and more.

No API key required. No authentication needed.

### What data can you scrape?

- **Token/pair search** — search any token by name, symbol, or address
- **Pairs by token address** — all DEX pairs for one or more token contract addresses
- **Specific pair lookup** — full data for a single pair by chain + pair address
- **Trending tokens** — top boosted/trending tokens across all chains
- **Token profiles** — latest token profiles with social links and descriptions

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | What to fetch: `search`, `byTokenAddress`, `byPairAddress`, `trending`, `byProfile` |
| `query` | string | Search query — token name, symbol, or address (mode=search) |
| `tokenAddresses` | string | Comma-separated token contract addresses, up to 30 (mode=byTokenAddress) |
| `chainId` | select | Filter by blockchain (ethereum, bsc, solana, base, etc.) |
| `pairAddress` | string | Pair contract address (mode=byPairAddress) |
| `minLiquidityUsd` | number | Filter pairs below this USD liquidity |
| `minVolumeH24` | number | Filter pairs below this 24h USD volume |
| `maxItems` | integer | Maximum records to emit (1–1000, default 50) |

#### Example inputs

**Search for USDC pairs:**
```json
{
  "mode": "search",
  "query": "USDC",
  "maxItems": 20
}
````

**Get all pairs for a token:**

```json
{
  "mode": "byTokenAddress",
  "tokenAddresses": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  "chainId": "ethereum"
}
```

**Get trending tokens:**

```json
{
  "mode": "trending",
  "maxItems": 50
}
```

### Output

Each record contains:

| Field | Description |
|-------|-------------|
| `chainId` | Blockchain name (ethereum, bsc, solana, …) |
| `dexId` | DEX protocol name (uniswap, pancakeswap, raydium, …) |
| `pairAddress` | Pair contract address |
| `pairUrl` | Direct link to the pair on DexScreener |
| `baseToken` | Base token info: address, name, symbol |
| `quoteToken` | Quote token info: address, name, symbol |
| `priceNative` | Price in native quote token units |
| `priceUsd` | Current USD price |
| `liquidity` | Liquidity: usd, base, quote |
| `fdv` | Fully diluted valuation (USD) |
| `marketCap` | Market cap (USD) |
| `volume` | Volume by period: h24, h6, h1, m5 |
| `priceChange` | Price change % by period: h24, h6, h1, m5 |
| `txns` | Transaction counts (buys/sells) by period |
| `pairCreatedAt` | ISO-8601 pair creation date |
| `labels` | Tags like \["v2", "v3", "pump.fun"] |
| `boosts` | Active boost count |
| `recordType` | "pair", "boostedToken", or "tokenProfile" |
| `siteName` | "DexScreener" |
| `scrapedAt` | ISO-8601 scrape timestamp |

#### Example output record

```json
{
  "chainId": "ethereum",
  "dexId": "uniswap",
  "pairAddress": "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
  "pairUrl": "https://dexscreener.com/ethereum/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
  "baseToken": {"address": "0xA0b86991...", "name": "USD Coin", "symbol": "USDC"},
  "quoteToken": {"address": "0xC02aaA39...", "name": "Wrapped Ether", "symbol": "WETH"},
  "priceUsd": "1.001",
  "liquidity": {"usd": 98765432.0, "base": 50000000.0, "quote": 26000.0},
  "volume": {"h24": 54321000.0, "h6": 12345000.0, "h1": 2100000.0, "m5": 350000.0},
  "priceChange": {"h24": -0.23, "h6": 0.12, "h1": -0.05, "m5": 0.01},
  "txns": {"h24": {"buys": 3200, "sells": 3100}},
  "pairCreatedAt": "2023-01-01T00:00:00+00:00",
  "labels": ["v3"],
  "recordType": "pair",
  "siteName": "DexScreener",
  "scrapedAt": "2026-05-10T12:00:00+00:00"
}
```

### Supported Blockchains

ethereum, bsc, polygon, arbitrum, optimism, base, avalanche, fantom, solana, cronos, celo, gnosis, moonbeam, moonriver, harmony, klaytn, fuse, heco, okex, cro

### FAQ

**Do I need an API key?**
No. DexScreener's public API requires no authentication.

**Is there a rate limit?**
DexScreener has no documented rate limit on most endpoints. The actor includes automatic retry logic for any 429 or 5xx responses.

**Can I search across all chains?**
Yes. Set `chainId` to "all" (the default) for cross-chain search.

**How fresh is the data?**
DexScreener updates in real time. Data reflects the state at the time of scraping.

**What is the `trending` mode?**
It fetches tokens with the most active boosts on DexScreener — a proxy for trending/promoted tokens.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from DexScreener.

## `query` (type: `string`):

Token name, symbol, or pair address to search (mode=search).

## `tokenAddresses` (type: `string`):

Comma-separated token contract addresses (up to 30). Example: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48

## `chainId` (type: `string`):

Blockchain network. Use 'all' to include all chains (only applies to search mode).

## `pairAddress` (type: `string`):

The pair contract address. Requires chainId to also be set (not 'all').

## `minLiquidityUsd` (type: `number`):

Filter out pairs with total liquidity below this USD value.

## `minVolumeH24` (type: `number`):

Filter out pairs with 24h trading volume below this USD value.

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

Maximum number of records to emit.

## Actor input object example

```json
{
  "mode": "search",
  "query": "USDC",
  "chainId": "all",
  "maxItems": 5
}
```

# Actor output Schema

## `records` (type: `string`):

Scraped records

# 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 = {
    "mode": "search",
    "query": "USDC",
    "chainId": "all",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "search",
    "query": "USDC",
    "chainId": "all",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/dexscreener-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "query": "USDC",
  "chainId": "all",
  "maxItems": 5
}' |
apify call crawlerbros/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/dexscreener-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DexScreener Scraper",
        "description": "Scrape DexScreener with real-time DEX token and trading pair data across 20+ blockchains. Search tokens, fetch pair details, trending/boosted tokens, and token profiles. No auth required.",
        "version": "1.0",
        "x-build-id": "D2h1HX7d1v7nxKZb3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~dexscreener-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-dexscreener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~dexscreener-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-dexscreener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~dexscreener-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-dexscreener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byTokenAddress",
                            "byPairAddress",
                            "trending",
                            "byProfile"
                        ],
                        "type": "string",
                        "description": "What to fetch from DexScreener.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Token name, symbol, or pair address to search (mode=search)."
                    },
                    "tokenAddresses": {
                        "title": "Token addresses (mode=byTokenAddress)",
                        "type": "string",
                        "description": "Comma-separated token contract addresses (up to 30). Example: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
                    },
                    "chainId": {
                        "title": "Chain",
                        "enum": [
                            "all",
                            "ethereum",
                            "bsc",
                            "polygon",
                            "arbitrum",
                            "optimism",
                            "base",
                            "avalanche",
                            "fantom",
                            "solana",
                            "cronos",
                            "celo",
                            "gnosis",
                            "moonbeam",
                            "moonriver",
                            "harmony",
                            "klaytn",
                            "fuse",
                            "heco",
                            "okex",
                            "cro"
                        ],
                        "type": "string",
                        "description": "Blockchain network. Use 'all' to include all chains (only applies to search mode).",
                        "default": "all"
                    },
                    "pairAddress": {
                        "title": "Pair address (mode=byPairAddress)",
                        "type": "string",
                        "description": "The pair contract address. Requires chainId to also be set (not 'all')."
                    },
                    "minLiquidityUsd": {
                        "title": "Min liquidity (USD)",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "number",
                        "description": "Filter out pairs with total liquidity below this USD value."
                    },
                    "minVolumeH24": {
                        "title": "Min 24h volume (USD)",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "number",
                        "description": "Filter out pairs with 24h trading volume below this USD value."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of records to emit.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
