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

Dexscreener scraper — search any keyword, token or pair, paste a Dexscreener URL, or pull live boost/profile feeds, and get clean per-pair rows: price, liquidity, FDV, market cap, 24h/6h/1h volume and change, buy/sell counts. Every chain, from Dexscreener's public API. No proxy. JSON or CSV out.

- **URL**: https://apify.com/memo23/dexscreener-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<h1 align="center">Dexscreener Scraper</h1>

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/dexscreener-logo.png" alt="Dexscreener Scraper" width="180" />
</p>

All-in-one **Dexscreener** scraper — search a keyword, drop a token or pair address, paste a Dexscreener URL, or pull a live discovery feed, and get clean per-pair rows: price, liquidity, volume, FDV, market cap, transaction counts and price changes across every chain.

| Input you give it | Rows you get back |
|---|---|
| Search keyword (`SOL`, `PEPE`, `USDC/SOL`) | Every matching pair |
| Token contract address | Every pool trading that token |
| Pair URL / `chain/pairAddress` | That exact pair |
| Discovery feed (latest profiles / boosts) | Pairs behind the trending tokens |

> Pure HTTP on Dexscreener's own public API. No browser, no CAPTCHA solver, no proxy required.

### Why Use This Scraper?

- **Four entry points in one actor** — keyword search, token/pair/URL lookup, and three discovery feeds. Mix them in one run.
- **Every chain** — Solana, Ethereum, Base, BSC, and any chain Dexscreener indexes. Optional single-chain filter.
- **Discovery built in** — pull the latest token profiles, the latest boosted tokens, or the most-boosted tokens right now, then resolve each to its live pairs.
- **Complete market snapshot per pair** — price (USD + native), liquidity, FDV, market cap, 24h/6h/1h volume and price change, buy/sell counts.
- **Cheap and fast** — Dexscreener's public API is generous; no proxy or anti-bot spend. De-duplicated by chain + pair address.

### Overview

This actor turns Dexscreener into structured, analysis-ready data for token research, market monitoring, screening bots, and portfolio dashboards. Every row is one trading pair, flattened into stable top-level fields, with the complete raw Dexscreener object preserved under `raw` for anything you need that isn't surfaced.

### Supported Inputs

| Input | Example | Notes |
|---|---|---|
| Search queries | `SOL`, `bonk`, `USDC/SOL` | Full-text search of Dexscreener's index |
| Token addresses | `So1111…1112` | Returns every pool trading that token, any chain |
| Pair URLs | `https://dexscreener.com/solana/<pairAddress>` | That single pair |
| `chain/pairAddress` | `solana/HcKh…pump` | Bare form of a pair lookup |
| Discovery mode | `latestProfiles` / `latestBoosts` / `topBoosts` | Live feeds, resolved to pairs |

**Not supported:** private/authenticated endpoints, historical OHLCV candles, or wallet-level holdings (those need a different data source).

### Use Cases

| Who | What they pull |
|---|---|
| Traders & screeners | Live price/liquidity/volume snapshots for a token list |
| Bot builders | A cheap, no-proxy feed of new & boosted pairs |
| Analysts | Cross-chain liquidity and volume distribution for a token |
| Researchers | The latest token profiles and boost activity as a discovery signal |

### How It Works

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/dexscreener-how-it-works.png" alt="How the Dexscreener Scraper works" width="820" />
</p>

1. **Point it at Dexscreener** — any mix of search queries, addresses/URLs, and a discovery feed.
2. **Fetch** — each input hits Dexscreener's public API with retry + backoff on rate limits. No proxy needed.
3. **Emit** — pairs are normalized into flat rows, de-duplicated by chain + pair address, and bounded by `maxItems`.

### Input Configuration

| Field | Type | Notes |
|---|---|---|
| `searchQueries` | string[] | Keywords / symbols to search |
| `urlsOrAddresses` | string[] | Pair URLs, `chain/pairAddress`, or token contract addresses |
| `discoveryMode` | enum | `none` (default), `latestProfiles`, `latestBoosts`, `topBoosts` |
| `chainFilter` | string | Keep only pairs on this chain (e.g. `solana`). Empty = all chains |
| `maxItems` | integer | Cap on total pairs returned |
| `proxy` | object | Optional — the public API rarely needs one |

#### Example input

```json
{
  "searchQueries": ["SOL", "PEPE"],
  "urlsOrAddresses": ["https://dexscreener.com/solana/HcKhfddNF2dqMxxtL51AzgWU26MBNkUkEzGAHtqkpump"],
  "discoveryMode": "topBoosts",
  "chainFilter": "solana",
  "maxItems": 200
}
````

### Output Overview

One row per pair. Numeric market fields are surfaced at the top level; the untouched Dexscreener pair object is kept under `raw`.

### Output Sample

```jsonc
{
  "chainId": "base",
  "dexId": "aerodrome",
  "url": "https://dexscreener.com/base/0x1131db5977242a03ebead1acd18f80a9a29e5922",
  "pairAddress": "0x1131DB5977242a03eBeaD1aCD18F80A9A29e5922",
  "baseTokenSymbol": "SOL",
  "quoteTokenSymbol": "USDC",
  "priceUsd": "75.97",
  "liquidityUsd": 353379.36,
  "fdv": 15507499,
  "marketCap": 15507499,
  "volume24h": 4054031.2,
  "priceChange24h": 1.49,
  "txns24h": { "buys": 4034, "sells": 4033 },
  "scrapedAt": "2026-07-19T10:28:33.734Z"
}
```

### Key Output Fields

- **Identity:** `chainId`, `dexId`, `url`, `pairAddress`, `baseTokenSymbol` / `baseTokenAddress`, `quoteTokenSymbol` / `quoteTokenAddress`
- **Price:** `priceUsd`, `priceNative`
- **Depth & size:** `liquidityUsd`, `fdv`, `marketCap`
- **Activity:** `volume24h` / `volume6h` / `volume1h`, `priceChange24h` / `priceChange6h` / `priceChange1h`, `txns24h`
- **Meta:** `pairCreatedAt`, `scrapedAt`, `raw` (full Dexscreener pair object)

### FAQ

**Do I need a proxy?** No. Dexscreener's public API is generous; the actor only backs off on the rare 429.

**Can I get every pool for a token?** Yes — pass the token contract address in `urlsOrAddresses`.

**Which chains are supported?** All chains Dexscreener indexes. Use `chainFilter` to restrict to one.

**What is discovery mode?** A live feed of trending/new tokens (profiles or boosts), each resolved to its pairs — handy as a screening signal.

**Historical candles?** Not included — this actor returns the current-state snapshot per pair.

### Support

Found a bug or need a field added? Open an issue on the actor's Issues tab, or email **muhamed.dido@gmail.com**.

### Explore More Scrapers

Browse the full catalog of production scrapers at [muhamed-didovic.github.io](https://muhamed-didovic.github.io/).

### ⚠️ Disclaimer

This Actor accesses publicly available market data on Dexscreener for legitimate research, market-intelligence, and analysis purposes. Use of this Actor must comply with Dexscreener's Terms of Service and all applicable laws. This is not financial advice — always verify token contracts independently before trading. The Actor's authors are not responsible for any misuse. We do not store any scraped data; the Actor returns it directly to your Apify dataset for your authorized use.

### SEO Keywords

dexscreener scraper, dexscreener api, dex screener data extraction, crypto pair scraper, token price scraper, solana token scraper, ethereum pair data, liquidity and volume scraper, dexscreener bulk export, on-chain market data, defi data api, token discovery feed, boosted tokens scraper, crypto market research, dexscreener json export, dexscreener csv export, memecoin scraper, dex pair monitor

# Actor input Schema

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

Keywords, symbols or names to search (e.g. <code>SOL</code>, <code>PEPE</code>, <code>USDC/SOL</code>). Each query returns its matching pairs.

## `urlsOrAddresses` (type: `array`):

Dexscreener pair URLs (e.g. <code>https://dexscreener.com/solana/\<pairAddress></code>), bare <code>chain/pairAddress</code>, or token contract addresses. Token addresses return every pool trading that token.

## `discoveryMode` (type: `string`):

Instead of (or in addition to) queries, pull a live discovery feed: the latest token profiles, the latest boosted tokens, or the most-boosted tokens right now.

## `chainFilter` (type: `string`):

Optional. Keep only pairs on this chain (e.g. <code>solana</code>, <code>ethereum</code>, <code>base</code>, <code>bsc</code>). Leave empty for all chains.

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

Maximum number of pairs to return across all inputs.

## `proxy` (type: `object`):

Optional. Dexscreener's public API is generous and usually needs no proxy; set this only if you hit rate limits.

## Actor input object example

```json
{
  "searchQueries": [
    "SOL"
  ],
  "discoveryMode": "none",
  "maxItems": 100
}
```

# 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": [
        "SOL"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "searchQueries": ["SOL"],
    "maxItems": 100,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dexscreener Scraper",
        "description": "Dexscreener scraper — search any keyword, token or pair, paste a Dexscreener URL, or pull live boost/profile feeds, and get clean per-pair rows: price, liquidity, FDV, market cap, 24h/6h/1h volume and change, buy/sell counts. Every chain, from Dexscreener's public API. No proxy. JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "EergMa62b30VZZt4L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~dexscreener-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~dexscreener-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~dexscreener-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords, symbols or names to search (e.g. <code>SOL</code>, <code>PEPE</code>, <code>USDC/SOL</code>). Each query returns its matching pairs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urlsOrAddresses": {
                        "title": "URLs, pair or token addresses",
                        "type": "array",
                        "description": "Dexscreener pair URLs (e.g. <code>https://dexscreener.com/solana/&lt;pairAddress&gt;</code>), bare <code>chain/pairAddress</code>, or token contract addresses. Token addresses return every pool trading that token.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "discoveryMode": {
                        "title": "Discovery mode",
                        "enum": [
                            "none",
                            "latestProfiles",
                            "latestBoosts",
                            "topBoosts"
                        ],
                        "type": "string",
                        "description": "Instead of (or in addition to) queries, pull a live discovery feed: the latest token profiles, the latest boosted tokens, or the most-boosted tokens right now.",
                        "default": "none"
                    },
                    "chainFilter": {
                        "title": "Chain filter",
                        "type": "string",
                        "description": "Optional. Keep only pairs on this chain (e.g. <code>solana</code>, <code>ethereum</code>, <code>base</code>, <code>bsc</code>). Leave empty for all chains."
                    },
                    "maxItems": {
                        "title": "Max pairs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pairs to return across all inputs.",
                        "default": 1000
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional)",
                        "type": "object",
                        "description": "Optional. Dexscreener's public API is generous and usually needs no proxy; set this only if you hit rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```