# DEX Screener Scraper (`parseforge/dexscreener-scraper`) Actor

Scrape live DEX trading pairs from DEX Screener public API. Look up a token address, a chain+pair address, or search by name/symbol. Returns price, volume, liquidity, FDV, transactions, and multi-window price change. No API key required.

- **URL**: https://apify.com/parseforge/dexscreener-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.87 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/raw/main/banner.jpg)

## 📊 DEX Screener Scraper

> 🚀 **Export live DEX trading pairs in seconds.** Look up a token contract, a chain + pair address, or run a free-text search to pull **price, liquidity, FDV, volume, transactions, and multi-window price change** for any pair on **20+ EVM and non-EVM chains**. No API key, no wallet, no manual JSON parsing.

> 🕒 **Last updated:** 2026-05-13 · **📊 31 fields** per pair · **🌐 20+ chains** · **🦄 Every DEX indexed by DEX Screener**

The **DEX Screener Scraper** queries the public DEX Screener API and returns a clean, structured record per trading pair, including base/quote token addresses, USD price, native price, 24h volume across four time windows, USD/base/quote liquidity, FDV, market cap, transaction counts (buys vs sells across m5/h1/h6/h24), and percent price change across four windows. The source feed is the same one that powers the DEX Screener web app, so every chain and DEX it lists is reachable from a single Actor input.

Coverage spans **Ethereum, BNB Smart Chain, Solana, Base, Arbitrum, Polygon, Avalanche, Optimism, Fantom, Blast, Linea, Scroll, zkSync, PulseChain, TON, Sui, Aptos, Tron, HyperEVM**, and more. Three lookup modes are baked in: full token sweep (every pair for a token contract), single pair lookup (chain + pair address), and search query (DEX Screener's name/symbol search, capped at ~30 pairs per query). Sort by 24h volume, USD liquidity, FDV, or 24h price change before applying maxItems. Download CSV, Excel, JSON, or XML.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto traders, DeFi researchers, on-chain analysts, market-data engineers, quant teams, alpha groups, token treasuries | Token monitoring, new-pair discovery, liquidity tracking, price-change alerts, FDV scans, multi-chain dashboards, market-maker monitoring |

---

### 📋 What the DEX Screener Scraper does

Three lookup workflows in a single run:

- 🪙 **Token address mode.** Drop in any token contract. Returns every pair where that token is one side, on every chain DEX Screener indexes.
- 🧭 **Chain + Pair address mode.** Look up one specific pair by chain slug (e.g. `solana`) and pair contract address.
- 🔍 **Search query mode.** Free-text search by token name, symbol, or pair (e.g. `USDC`, `PEPE`, `wif`). DEX Screener's search endpoint caps results at roughly 30 pairs per query.
- 🔽 **Sort.** Order by 24h volume, USD liquidity, FDV, or 24h price change before slicing to maxItems.

Each pair record carries the DEX Screener URL, chain ID, DEX ID, pair contract address, base and quote token metadata, USD and native price, 4-window volume (m5/h1/h6/h24), USD + base + quote liquidity, FDV, market cap, percent price change across 4 windows, and buy/sell counts across 4 windows.

> 💡 **Why it matters:** DeFi moves in seconds. Manually polling DEX Screener through a browser or rolling your own multi-chain aggregator is fragile and slow. This Actor returns a clean JSON record per pair with every metric the web UI surfaces, ready for dashboards, alerts, or quant pipelines.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to look up a token, sort by liquidity, and ship the dataset into Google Sheets._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>"USDC"</code></td><td>Free-text DEX Screener search (token name, symbol, or pair). Caps at ~30 pairs per query.</td></tr>
<tr><td><code>tokenAddress</code></td><td>string</td><td><code>""</code></td><td>Token contract. Returns every pair where this token is one side.</td></tr>
<tr><td><code>chain</code></td><td>string (enum)</td><td><code>""</code></td><td>Chain slug used with Pair Address. 20 supported (ethereum, bsc, solana, base, arbitrum, polygon, avalanche, optimism, fantom, blast, linea, scroll, zksync, pulsechain, ton, sui, aptos, tron, hyperevm).</td></tr>
<tr><td><code>pairAddress</code></td><td>string</td><td><code>""</code></td><td>Pair contract address. Requires <code>chain</code> to be set. Returns just that pair.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>sortBy</code></td><td>string (enum)</td><td><code>""</code></td><td>Order before applying maxItems. Options: volume24h, liquidityUsd, fdv, priceChange24h.</td></tr>
</tbody>
</table>

**Example: every pair for USDC on every chain, sorted by 24h volume.**

```json
{
    "tokenAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "maxItems": 50,
    "sortBy": "volume24h"
}
````

**Example: single Solana pair by address.**

```json
{
    "chain": "solana",
    "pairAddress": "8sLbNZoA1cfnvMJLPfp98ZLAnFSYCFApfJKMbiXNLwxj",
    "maxItems": 1
}
```

> ⚠️ **Good to Know:** the search endpoint caps results at roughly 30 pairs per query regardless of `maxItems`. For wider coverage on a specific token, use Token Address mode. For exotic pairs, drop the chain + pair address pair directly.

***

### 📊 Output

Each pair record contains up to **31 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔗 `url` | string | `"https://dexscreener.com/pulsechain/0xc636bfe0..."` |
| 🌐 `chainId` | string | `"pulsechain"` |
| 🦄 `dexId` | string | `"pulsex"` |
| 🏷️ `pairAddress` | string | `"0xC636bfE0bAe34824380B4E26Bc34e4614e55e483"` |
| 🪙 `baseToken` | object | `{ address, name, symbol }` |
| 💱 `quoteToken` | object | `{ address, name, symbol }` |
| 💵 `priceUsd` | number | null | `0.0007103` |
| 🪙 `priceNative` | number | null | `0.02176` |
| 📈 `volume24h` | number | null | `4258.02` |
| ⏱️ `volumeH6` | number | null | `1883.93` |
| ⏱️ `volumeH1` | number | null | `43.16` |
| ⏱️ `volumeM5` | number | null | `0.26` |
| 💧 `liquidityUsd` | number | null | `5720878.31` |
| 💧 `liquidityBase` | number | null | `4026714275` |
| 💧 `liquidityQuote` | number | null | `87659182` |
| 🪙 `fdv` | number | null | `20229503` |
| 💼 `marketCap` | number | null | `43262129` |
| 📊 `priceChangeM5` | number | null | `0.75` |
| 📊 `priceChangeH1` | number | null | `0.75` |
| 📊 `priceChangeH6` | number | null | `6.65` |
| 📊 `priceChangeH24` | number | null | `1.76` |
| 🔁 `txnsM5Buys` | number | null | `0` |
| 🔁 `txnsM5Sells` | number | null | `1` |
| 🔁 `txnsH1Buys` | number | null | `0` |
| 🔁 `txnsH1Sells` | number | null | `7` |
| 🔁 `txnsH6Buys` | number | null | `2` |
| 🔁 `txnsH6Sells` | number | null | `175` |
| 🔁 `txnsH24Buys` | number | null | `18` |
| 🔁 `txnsH24Sells` | number | null | `241` |
| 🏷️ `labels` | string\[] (optional) | `["v1"]` |
| 🕒 `pairCreatedAt` | ISO 8601 (optional) | `"2023-05-29T01:57:25.000Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T22:20:40.453Z"` |

#### 📦 Sample records

<details>
<summary><strong>🦄 PulseChain USDC/ATROPA on PulseX</strong></summary>

```json
{
    "url": "https://dexscreener.com/pulsechain/0xc636bfe0bae34824380b4e26bc34e4614e55e483",
    "chainId": "pulsechain",
    "dexId": "pulsex",
    "pairAddress": "0xC636bfE0bAe34824380B4E26Bc34e4614e55e483",
    "baseToken": {
        "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "name": "USD Coin",
        "symbol": "USDC"
    },
    "quoteToken": {
        "address": "0xCc78A0acDF847A2C1714D2A925bB4477df5d48a6",
        "name": "Atropa",
        "symbol": "ATROPA"
    },
    "priceUsd": 0.0007103,
    "priceNative": 0.02176,
    "volume24h": 4258.02,
    "volumeH6": 1883.93,
    "volumeH1": 43.16,
    "volumeM5": 0.26,
    "liquidityUsd": 5720878.31,
    "liquidityBase": 4026714275,
    "liquidityQuote": 87659182,
    "fdv": 20229503,
    "marketCap": 43262129,
    "priceChangeH1": 0.75,
    "priceChangeH6": 6.65,
    "priceChangeH24": 1.76,
    "txnsH24Buys": 18,
    "txnsH24Sells": 241,
    "labels": ["v1"],
    "pairCreatedAt": "2023-05-29T01:57:25.000Z",
    "scrapedAt": "2026-05-13T22:20:40.453Z"
}
```

</details>

<details>
<summary><strong>🧾 PulseChain USDC/DAI on PulseX v2</strong></summary>

```json
{
    "url": "https://dexscreener.com/pulsechain/0x2db5ef4e8a7dbe195defae2d9b79948096a03274",
    "chainId": "pulsechain",
    "dexId": "pulsex",
    "pairAddress": "0x2dB5EF4E8A7Dbe195defAe2d9b79948096a03274",
    "baseToken": { "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "name": "USD Coin", "symbol": "USDC" },
    "quoteToken": { "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F", "name": "Dai Stablecoin", "symbol": "DAI" },
    "priceUsd": 0.0007058,
    "volume24h": 1777.46,
    "liquidityUsd": 46893.64,
    "fdv": 20101943,
    "priceChangeH24": 0.78,
    "labels": ["v2"],
    "pairCreatedAt": "2023-06-01T20:30:45.000Z",
    "scrapedAt": "2026-05-13T22:20:40.453Z"
}
```

</details>

<details>
<summary><strong>🪙 USDC/HEX low-liquidity pair on Uniswap PulseChain fork</strong></summary>

```json
{
    "url": "https://dexscreener.com/pulsechain/0xe05e653453f733786f2dabae0ffa1e96cfcc4b25",
    "chainId": "pulsechain",
    "dexId": "uniswap",
    "pairAddress": "0xe05e653453F733786F2DABae0ffa1e96cFcc4b25",
    "baseToken": { "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "name": "USD Coin", "symbol": "USDC" },
    "quoteToken": { "address": "0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39", "name": "HEX", "symbol": "HEX" },
    "priceUsd": 0.0006948,
    "volume24h": 0.18,
    "liquidityUsd": 378.62,
    "priceChangeM5": 3.79,
    "txnsH24Buys": 1,
    "txnsH24Sells": 1,
    "scrapedAt": "2026-05-13T22:20:40.454Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌐 | **20+ chains, one Actor.** Ethereum, BNB, Solana, Base, Arbitrum, Polygon, Avalanche, Optimism, Fantom, Blast, Linea, Scroll, zkSync, PulseChain, TON, Sui, Aptos, Tron, HyperEVM. |
| 🎯 | **Three lookup modes.** Token contract, chain + pair, or free-text search. Same output schema across all three. |
| ⚡ | **Live data.** Every run hits the DEX Screener API. No staleness, no caching. |
| 🔁 | **Multi-window metrics.** Volume, price change, and buy/sell counts at m5, h1, h6, and h24 in a single record. |
| 💧 | **Liquidity breakdown.** USD, base, and quote liquidity for sizing trades and spotting thin books. |
| 🚫 | **No API key.** Works against the public DEX Screener API. No wallet, no signing. |
| 🔽 | **Server-side sort.** Volume, liquidity, FDV, or 24h price change before the maxItems slice. |

> 📊 Accurate, multi-window DEX pair data is the foundation of every trading dashboard, new-listing alert, and DeFi liquidity model.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ DEX Screener Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **20+ chains, all DEXs** | **Live per run** | token, chain+pair, search, sort | ⚡ 2 min |
| DEX Screener web app | Free | Same | Live | Manual click-through | 🐢 Browser only |
| Subgraph queries (The Graph) | Pay per query | Per-subgraph | Indexer-dependent | GraphQL, per-DEX | 🛠️ Hours per chain |
| Roll your own RPC pipeline | Free + RPC cost | Whatever you build | Whatever you build | Whatever you build | 🐌 Weeks |

Pick this Actor when you want broad multi-chain DEX coverage, server-side sorting, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the DEX Screener Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode (token, chain+pair, or search), set `maxItems`, and optionally `sortBy`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab CSV, Excel, JSON, or XML from the **Dataset** tab.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Trading & Market Making

- Live cross-DEX pricing for arbitrage scans
- Spread and depth comparison across pools
- Volume share by DEX for routing decisions
- 24h winners and losers boards

</td>
<td width="50%" valign="top">

#### 🧠 DeFi Research & Analytics

- TVL and liquidity tracking per pair
- New-pair discovery on every chain
- FDV vs market cap dilution checks
- Buy/sell pressure across time windows

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🪙 Token Teams & Treasuries

- Monitor your token's pools and prices
- Detect new pairs that wrap or fork your token
- Watch liquidity migration across DEXs
- Track FDV against tokenomics targets

</td>
<td width="50%" valign="top">

#### 🚨 Alerts & Dashboards

- Price-change triggers per chain
- Volume-spike alerts on watched pairs
- Slack or Telegram bots with live pair data
- Multi-chain portfolio dashboards

</td>
</tr>
</table>

***

### 🔌 Automating DEX Screener Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly polling for watched tokens, daily snapshots for analytics warehouses, or minute-by-minute refreshes for trading dashboards.

***

### 🌟 Beyond business use cases

DEX pair data powers more than trading desks. The same structured records support research, education, and personal projects.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Quantitative DeFi research on AMM efficiency
- Empirical liquidity studies across chains
- Reproducible event studies on token launches
- Coursework on on-chain market microstructure

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, indie trading bots, and portfolio dashboards
- Watchlists for personal holdings across chains
- Hackathon prototypes with live DEX data
- Content creation for crypto analysts and YouTubers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Community and education

- Transparent liquidity scoreboards for DAOs
- Open dashboards for community-watched pools
- Tutorials and learn-to-trade materials
- Open-source research repositories

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models for token-pair classification
- Backtest mempool and routing strategies
- Prototype on-chain anomaly detectors
- Stress-test indexers against live data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20DEX%20Screener%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20DEX%20Screener%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20DEX%20Screener%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20DEX%20Screener%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a lookup mode (token address, chain + pair address, or search query), click Start, and the Actor calls the DEX Screener public API and emits a structured record per pair with price, liquidity, volume, FDV, transactions, and price-change windows.

#### 🌐 Which chains does it cover?

20 chain slugs are enumerated in the input: ethereum, bsc, solana, base, arbitrum, polygon, avalanche, optimism, fantom, blast, linea, scroll, zksync, pulsechain, ton, sui, aptos, tron, hyperevm, and more. Token Address and Search modes return results across every chain DEX Screener indexes.

#### 🔍 Why does my search return only ~30 results?

The DEX Screener search endpoint caps results at roughly 30 pairs per query, regardless of `maxItems`. For wider coverage on a single token, use Token Address mode (it returns every pair where that token is one side).

#### 🪙 Do I need an API key or wallet?

No. The Actor uses the public DEX Screener API. No authentication, no wallet, no signing.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval. Run minute-by-minute for live dashboards, hourly for analytics, or daily for snapshots.

#### 🔁 How often is the data refreshed?

Every run hits the DEX Screener API directly. The data reflects current pool state at run time, with no caching.

#### 💧 Are liquidity numbers in USD or native?

All three: `liquidityUsd`, `liquidityBase`, and `liquidityQuote`. Same for price (USD and native side-by-side).

#### 📊 What's the difference between FDV and market cap?

FDV (fully diluted valuation) uses total supply. Market cap uses circulating supply. Both fields are populated when DEX Screener publishes them.

#### 🔁 What happens if a run fails?

Apify retries transient errors automatically. If a run still fails, inspect the log in the Runs tab, adjust the input, and re-run. Partial datasets are preserved.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers testing and small runs (10 pairs per run). A paid plan lifts the limit and unlocks scheduling and larger datasets.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

DEX Screener Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Pipe price-change alerts into channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Land DEX data in your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Pipe new pairs into your trading bot, or fire Slack alerts on volume spikes.

***

### 🔗 Recommended Actors

- [**🦎 CoinGecko Cryptocurrency Scraper**](https://apify.com/parseforge/coingecko-scraper) - Coin-level market data across thousands of assets
- [**🏦 Binance Crypto Prices Scraper**](https://apify.com/parseforge/binance-prices-scraper) - Live spot tickers on the largest CEX
- [**🪙 CoinPaprika Crypto Tickers Scraper**](https://apify.com/parseforge/coinpaprika-tickers-scraper) - Multi-source coin tickers with deep history
- [**📈 DefiLlama DeFi Protocol Scraper**](https://apify.com/parseforge/defillama-scraper) - TVL and protocol-level DeFi metrics
- [**💱 Yahoo Finance Stock & Crypto Scraper**](https://apify.com/parseforge/yahoo-finance-scraper) - Cross-asset quotes for crypto, equities, FX

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more crypto and market-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by DEX Screener or any DEX referenced in this README. All trademarks mentioned are the property of their respective owners. Only publicly available pair data exposed by DEX Screener's public API is collected. This Actor is for informational use only and does not constitute financial advice.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text query for the DEX Screener search endpoint (e.g. token name, symbol, or pair). DEX Screener's search endpoint caps results at ~30 pairs per query regardless of maxItems. For wider coverage, use Token Address mode (returns every pair where that token is one side). Leave empty if using Token Address or Pair Address mode.

## `tokenAddress` (type: `string`):

Contract address of a token. Returns every pair where this token is one side. Leave empty if not using.

## `chain` (type: `string`):

Chain slug used with Pair Address (e.g. ethereum, bsc, solana, base, arbitrum). Required if Pair Address is set.

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

Pair contract address. Requires Chain to be set. Returns just that pair.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `sortBy` (type: `string`):

Order results before applying maxItems.

## Actor input object example

```json
{
  "searchQuery": "USDC",
  "tokenAddress": "",
  "chain": "",
  "pairAddress": "",
  "maxItems": 10,
  "sortBy": ""
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete 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 = {
    "searchQuery": "USDC",
    "tokenAddress": "",
    "chain": "",
    "pairAddress": "",
    "maxItems": 10,
    "sortBy": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchQuery": "USDC",
    "tokenAddress": "",
    "chain": "",
    "pairAddress": "",
    "maxItems": 10,
    "sortBy": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchQuery": "USDC",
  "tokenAddress": "",
  "chain": "",
  "pairAddress": "",
  "maxItems": 10,
  "sortBy": ""
}' |
apify call parseforge/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DEX Screener Scraper",
        "description": "Scrape live DEX trading pairs from DEX Screener public API. Look up a token address, a chain+pair address, or search by name/symbol. Returns price, volume, liquidity, FDV, transactions, and multi-window price change. No API key required.",
        "version": "0.0",
        "x-build-id": "nU9rpxWG1nPBQGeyl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dexscreener-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~dexscreener-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~dexscreener-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text query for the DEX Screener search endpoint (e.g. token name, symbol, or pair). DEX Screener's search endpoint caps results at ~30 pairs per query regardless of maxItems. For wider coverage, use Token Address mode (returns every pair where that token is one side). Leave empty if using Token Address or Pair Address mode.",
                        "default": ""
                    },
                    "tokenAddress": {
                        "title": "Token Address",
                        "type": "string",
                        "description": "Contract address of a token. Returns every pair where this token is one side. Leave empty if not using.",
                        "default": ""
                    },
                    "chain": {
                        "title": "Chain ID (for Pair Address mode)",
                        "enum": [
                            "",
                            "ethereum",
                            "bsc",
                            "solana",
                            "base",
                            "arbitrum",
                            "polygon",
                            "avalanche",
                            "optimism",
                            "fantom",
                            "blast",
                            "linea",
                            "scroll",
                            "zksync",
                            "pulsechain",
                            "ton",
                            "sui",
                            "aptos",
                            "tron",
                            "hyperevm"
                        ],
                        "type": "string",
                        "description": "Chain slug used with Pair Address (e.g. ethereum, bsc, solana, base, arbitrum). Required if Pair Address is set.",
                        "default": ""
                    },
                    "pairAddress": {
                        "title": "Pair Address",
                        "type": "string",
                        "description": "Pair contract address. Requires Chain to be set. Returns just that pair.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "",
                            "volume24h",
                            "liquidityUsd",
                            "fdv",
                            "priceChange24h"
                        ],
                        "type": "string",
                        "description": "Order results before applying maxItems.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
