# Dexscreener Scraper (`automation-lab/dexscreener-token-pair-market-data`) Actor

Search tokens and export DexScreener pair prices, liquidity, volume, transactions, identities, DEX metadata, and source URLs for recurring crypto-market monitoring.

- **URL**: https://apify.com/automation-lab/dexscreener-token-pair-market-data.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Dexscreener Scraper

Search tokens and export normalized DexScreener pair market data for one-time analysis or scheduled crypto-market monitoring. The Actor turns token searches, contract addresses, and exact pair URLs into typed rows with chain, DEX, token identity, price, liquidity, volume, transactions, pool metadata, and the canonical source URL.

It uses DexScreener's public structured data surface directly. No browser, login, wallet, or proxy is required.

### What does this DexScreener scraper do?

The Actor supports three useful entry points:

1. Search by token name, symbol, contract, or pair phrase.
2. Resolve all reported pairs for an exact token contract and chain.
3. Refresh an exact `dexscreener.com/{chain}/{pair}` URL.

All routes produce the same stable dataset schema. Chain, DEX, and minimum-liquidity filters apply before charging or saving records. Duplicate pools found through multiple inputs are saved once.

### Who is it for?

- Crypto analysts building repeatable token-pair snapshots.
- Data teams comparing liquidity and volume across DEXs.
- Traders researching markets without manually copying pages.
- Developers who need a simple DexScreener API workflow on Apify.
- Operators scheduling recurring runs and comparing datasets downstream.

This product returns market records, not trading advice, alerts, wallets, or transaction execution.

### Why use it?

- **Three input routes:** broad discovery, exact token lookup, and exact pair refresh.
- **Normalized rows:** every result uses the same fields across chains and DEXs.
- **Useful activity windows:** five-minute, one-hour, six-hour, and 24-hour volume, price change, buys, and sells.
- **Early filtering:** reduce noisy results with chain, DEX, and USD-liquidity criteria.
- **Monitoring-ready provenance:** each row includes its input route, input value, source URL, and collection time.
- **Low overhead:** direct public JSON requests avoid browser and proxy costs.

### What data can I extract?

| Group | Fields |
| --- | --- |
| Pair identity | `chainId`, `dexId`, `pairAddress`, `pairUrl`, `labels` |
| Base token | address, name, symbol |
| Quote token | address, name, symbol |
| Price | native price and USD price |
| Liquidity | USD, base-token, and quote-token liquidity |
| Valuation | FDV and market cap when supplied |
| Volume | 5m, 1h, 6h, and 24h |
| Price change | 5m, 1h, 6h, and 24h percentages |
| Transactions | buy and sell counts for every time window |
| Project context | image, website URLs, and social URLs when supplied |
| Provenance | source input type, source input, and `scrapedAt` |

DexScreener does not populate every field for every pool. Missing numeric values are returned as `null`; optional lists are empty.

### How do I get started?

1. Open the Actor in Apify Console.
2. Enter one or more **Token search terms**, **Token contracts**, or **DexScreener pair URLs**.
3. Set `maxItems` to cap the total unique pair rows.
4. Optionally add chain IDs, DEX IDs, or minimum USD liquidity.
5. Click **Start**.
6. Open the **Dataset** tab and export JSON, CSV, Excel, XML, or another supported format.
7. Save the run as a Task and schedule it when you need recurring snapshots.

The prefilled `SOL USDC` search is intentionally small and works without credentials.

### Input parameters

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `searchTerms` | string array | prefilled with `SOL USDC` | Search names, symbols, contracts, or pair phrases. |
| `tokenTargets` | object array | empty | Resolve pairs for `{ "chainId", "address" }`. |
| `pairUrls` | string array | empty | Fetch exact public DexScreener pair pages. |
| `maxItems` | integer | `100` | Stop after 1–1,000 unique accepted rows. |
| `chainIds` | string array | empty | Keep only listed DexScreener chain IDs. |
| `dexIds` | string array | empty | Keep only listed DexScreener DEX IDs. |
| `minLiquidityUsd` | number | `0` | Keep pairs at or above this reported liquidity. |

Provide at least one search term, token target, or pair URL. Empty strings, malformed pair URLs, missing token fields, and invalid limits fail with a non-zero run status.

### Example inputs

#### Search token pairs

```json
{
  "searchTerms": ["Jupiter"],
  "maxItems": 20
}
```

#### Fetch one exact pair

```json
{
  "pairUrls": [
    "https://dexscreener.com/solana/58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
  ],
  "maxItems": 5
}
```

#### Monitor liquid SOL markets

```json
{
  "tokenTargets": [
    {
      "chainId": "solana",
      "address": "So11111111111111111111111111111111111111112"
    }
  ],
  "chainIds": ["solana"],
  "minLiquidityUsd": 100000,
  "maxItems": 25
}
```

### Output example

An exact SOL/USDC pair run returned a record shaped like this:

```json
{
  "chainId": "solana",
  "dexId": "raydium",
  "pairAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
  "pairUrl": "https://dexscreener.com/solana/58oqchx4ywmvkdwllzzbi4chocc2fqcuwbkwmihlyqo2",
  "baseTokenSymbol": "SOL",
  "quoteTokenSymbol": "USDC",
  "priceUsd": "103.64",
  "liquidityUsd": 14339378.74,
  "volume24h": 19895176.2,
  "buys24h": 69062,
  "sells24h": 69030,
  "sourceInputType": "pairUrl",
  "sourceInput": "https://dexscreener.com/solana/58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
  "scrapedAt": "2026-08-31T12:00:00.000Z"
}
```

Prices and activity values change continuously. Treat the example as a schema illustration, not a current quote.

### How much does it cost to extract DexScreener token pairs?

Pay-per-event pricing has a **$0.005 Actor start** and one `item` event for each unique pair record saved. The BRONZE item rate is **$0.0016**, with lower rates at higher pricing tiers.

BRONZE examples use the same formula at every scale: multiply accepted pair rows by the active **$0.0016 item rate**, then add the **$0.005 start fee**. For example, a 25-row run is `25 × item rate + start fee`; a 100-row run is `100 × item rate + start fee`. Higher Apify pricing tiers use their lower active item rate.

Filtered, duplicate, malformed, empty, or failed records are not charged as items. Your Apify plan determines the tier applied to item events. The source can return fewer pairs than `maxItems`; that limit is a cap, not a guaranteed count.

### Schedule recurring market monitoring

Create a Task from a tested input, then use an Apify schedule to run it hourly, daily, or at another interval. Each run creates a separate dataset with a `scrapedAt` timestamp. Compare the newest dataset with an earlier one in your database, spreadsheet pipeline, webhook receiver, or automation platform.

The Actor produces snapshots. It does not maintain history, calculate deltas, or send trading alerts by itself.

### Integrations and export workflows

Common patterns include:

- Export CSV into a spreadsheet for liquidity review.
- Send run-finished webhooks to Make, Zapier, or n8n.
- Load JSON rows into BigQuery, Snowflake, PostgreSQL, or a lakehouse.
- Join pairs by `chainId` and `pairAddress` across scheduled snapshots.
- Filter high-liquidity markets before a downstream research model.
- Use Apify datasets as a stable boundary between collection and analysis.

Never key records only by symbol. Symbols can collide; use chain plus pair address.

### Run through the Apify API

Replace `APIFY_TOKEN` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~dexscreener-token-pair-market-data/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["Jupiter"],"maxItems":20}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dexscreener-token-pair-market-data').call({
    tokenTargets: [{
        chainId: 'solana',
        address: 'So11111111111111111111111111111111111111112',
    }],
    minLiquidityUsd: 100000,
    maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/dexscreener-token-pair-market-data").call(
    run_input={
        "pairUrls": [
            "https://dexscreener.com/solana/58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
        ],
        "maxItems": 5,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

#### Claude Code setup

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/dexscreener-token-pair-market-data"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this MCP server JSON in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/dexscreener-token-pair-market-data"
    }
  }
}
```

Example prompts:

- “Search DexScreener for Jupiter pairs and return the 20 most useful rows.”
- “Fetch this DexScreener pair URL and summarize 24-hour liquidity, volume, buys, and sells.”
- “Resolve liquid SOL pairs on Solana and give me JSON for further analysis.”

### Reliability and retry behavior

Requests use the public DexScreener structured API with conservative pacing. Network timeouts, HTTP 429 responses, and temporary 5xx responses receive up to three bounded attempts with exponential backoff and jitter. Stable client errors do not retry blindly.

When some inputs fail and others succeed, valid rows are saved and failures appear in logs. When every upstream request fails, the run fails rather than returning a misleading successful empty dataset.

### Limits and data freshness

- Search result ordering and count are controlled by DexScreener.
- The public API does not provide pagination for the search response used here.
- `maxItems` stops collection but cannot force the source to produce that many rows.
- Values are point-in-time source observations, not guaranteed real-time quotes.
- Thin pools may omit liquidity, market cap, FDV, or activity windows.
- Search can include unrelated or similarly named tokens; use exact token targets or pair URLs for precision.
- Historical candles, holders, top traders, swaps, alerts, and order execution are outside scope.
- The Actor does not use a proxy setting because the working public API route does not require one.

### Legality and responsible use

DexScreener data is public market information, but users remain responsible for complying with applicable source terms, exchange rules, laws, and contractual obligations. Do not treat automated output as financial advice or as a guarantee of market quality. Validate addresses, timestamps, liquidity, and prices independently before making financial decisions.

Avoid using token names or symbols as identity. Malicious projects can imitate legitimate assets.

### Troubleshooting

#### Why did I receive zero records?

The query may have no current matches, or every result may have been removed by chain, DEX, or liquidity filters. Remove filters, reduce `minLiquidityUsd`, and inspect the run log.

#### Why does a search contain an unexpected token?

DexScreener controls search ranking and token metadata. Use a chain/token contract target or exact pair URL when identity matters.

#### Why did the run fail?

Check for malformed URLs, empty strings, incomplete token target objects, invalid limits, or a temporary source outage. A run where every source request fails intentionally returns a failed status.

#### Why are values `null`?

The upstream pair did not expose that metric. Nulls preserve the difference between unavailable data and a measured zero.

#### Can I request more than 1,000 rows?

One run is capped at 1,000 unique rows. Split independent target groups across Tasks when you need a larger bounded workflow. Search endpoints themselves may return much less.

### Related Automation Lab Actors

- [CoinGecko Crypto Market Data](https://apify.com/automation-lab/coingecko-crypto-market-data) for broader cryptocurrency market and historical records from CoinGecko.
- [Pump.fun New Token Listings Scraper](https://apify.com/automation-lab/pumpfun-new-token-listings-scraper) for newly listed Pump.fun token discovery.

Use this Actor when DexScreener pair identity, pool liquidity, DEX activity, and the canonical pair URL are the required source-specific output.

### FAQ

**Does it require a DexScreener account or API key?**\
No. The implemented public pair-data routes are anonymous.

**Does it trade tokens?**\
No. It only collects public market records.

**Can I filter Solana or Ethereum pairs?**\
Yes. Use `chainIds` with DexScreener's chain identifiers.

**Can I target one DEX?**\
Yes. Use `dexIds`, for example `raydium` or `uniswap` when those IDs appear in source records.

**Are duplicate pools charged twice?**\
No. A chain and pair-address key is saved and charged once per run, even if multiple inputs find it.

**Can I build a time series?**\
Yes. Schedule repeated Tasks and store each run's dataset externally. The Actor emits snapshots rather than maintaining a cross-run database.

**Is every field always available?**\
No. DexScreener coverage varies by chain, DEX, token, and pool. Optional fields remain nullable by design.

# Actor input Schema

## `searchTerms` (type: `array`):

Token names, symbols, contract addresses, or pair names to search through DexScreener.

## `tokenTargets` (type: `array`):

Exact token contracts. Each object needs the DexScreener chain ID and token address.

## `pairUrls` (type: `array`):

Exact public pair pages such as https://dexscreener.com/solana/<pair-address>.

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

Maximum number of unique pair records saved across all inputs.

## `chainIds` (type: `array`):

Optional DexScreener chain IDs to keep, such as solana, ethereum, or bsc.

## `dexIds` (type: `array`):

Optional DexScreener DEX IDs to keep, such as raydium or uniswap.

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

Keep only pairs whose reported USD liquidity is at least this amount.

## Actor input object example

```json
{
  "searchTerms": [
    "SOL USDC"
  ],
  "tokenTargets": [],
  "pairUrls": [],
  "maxItems": 20,
  "chainIds": [],
  "dexIds": [],
  "minLiquidityUsd": 0
}
```

# Actor output Schema

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

Default dataset view containing the collected DexScreener pair 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 = {
    "searchTerms": [
        "SOL USDC"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dexscreener-token-pair-market-data").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 = {
    "searchTerms": ["SOL USDC"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dexscreener-token-pair-market-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "SOL USDC"
  ],
  "maxItems": 20
}' |
apify call automation-lab/dexscreener-token-pair-market-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/dexscreener-token-pair-market-data"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FdahVPwYaTeoysDsF/builds/Oz5xWv2ofzBszbIqr/openapi.json