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

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

Fetch one exact pair

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

Monitor liquid SOL markets

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

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

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

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

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:

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:

{
  "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 for broader cryptocurrency market and historical records from CoinGecko.
• Pump.fun 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.