# DexScreener Scraper — Token Prices & DEX Pairs (`s-r/dexscreener-scraper`) Actor

Collect DexScreener token prices, DEX pairs, liquidity, volume and socials. Search symbols, batch token or pair addresses across chains, and resolve latest profiles or boosted tokens to pair rows.

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

## Pricing

$2.00 / 1,000 pairs

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## DexScreener API Scraper

Collect token prices, liquidity, trading volume and DEX pairs with this DexScreener API
scraper. Search by symbol or token name, submit token and pair addresses, or turn the latest
token profiles and boosted-token feeds into a dataset of unique pairs across chains.

### What the DexScreener API scraper collects

Each successful row represents one trading pair on one chain and DEX. Rows include the base
and quote token addresses, names and symbols; price in USD and quote-token units; liquidity;
fully diluted valuation; market capitalization; and pool creation time. Trading activity is
available for five minutes, one hour, six hours and twenty-four hours, including volume,
percentage price changes and buy and sell counts where the source supplies them.

Token profile websites, social links and image URLs are included when available. Rows from
a selected feed also carry its profile description, links and boost information. The original
baseToken, quoteToken, txns, volume, priceChange, liquidity, info and boosts objects remain
available alongside the flat fields, which helps when adapting an existing DexScreener integration.

### Input

Start with a search such as PEPE, WIF or SOL/USDC. A search returns up to thirty pairs in the
source order, possibly across several chains. For a specific asset, use its token address
and chain. Symbols can refer to unrelated tokens, so an address is the better choice when
identity matters.

This input uses two real Solana token addresses from the captured source responses:

```json
{
  "chain": "solana",
  "token_addresses": [
    "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm",
    "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263"
  ],
  "max_items": 100
}
```

Use `queries` for up to twenty search terms, `token_addresses` for up to three hundred token
addresses, and `pair_addresses` for up to three hundred pool addresses. Unprefixed addresses
use `chain`, which defaults to solana. Mix chains by writing chain:address, such as an ethereum
prefix before an Ethereum address. The actor accepts chain IDs beyond a fixed shortlist;
whether an address resolves depends on DexScreener coverage.

The `feeds` array accepts latest_profiles, latest_boosts and top_boosts. Feed entries are
tokens, which are resolved to pairs. Repeated tokens within a feed are removed before
resolution. Profiles or boosts do not guarantee a live pool, liquidity or future activity.

By default, a token address returns the main pair selected by DexScreener. This may differ
from the pool with the highest liquidity. Set `all_pairs` to true for up to twenty explicit
token addresses to request their available pools, with a source limit of thirty pools per
token. Only pools where the requested token is the base token are returned. Feeds continue
to use main pairs. `max_items`, from one to one thousand, limits unique pair rows across the
run. Large inputs may need to be split into smaller runs if their request plan is too large.

### Output

Download the default dataset as JSON, CSV or Excel, or consume it through the Apify dataset
API. Useful flat fields include symbol, exchange, chain, price, price_native, liquidity_usd,
market_cap, fdv, volume_h24, price_change_h24, buys_h24, sells_h24 and pair_address. Equivalent
activity fields exist for m5, h1, h6 and h24. The price currency is USD; native price uses the
quote token rather than a fixed currency shared by all chains.

Missing source values stay null. An absent price-change window is not reported as zero.
`fetched_at` records retrieval time in UTC. `as_of` remains null because the source does not
provide an observation timestamp for each price. Responses can reflect cached data, so these
rows are snapshots rather than a tick stream. Pool creation time describes the pool itself.

Duplicate pairs are removed using chain and pair address. The first matching input retains
attribution. Results follow search terms, token addresses, pair addresses and feeds in that
order, preserving each input's order. Missing addresses receive diagnostic rows when other
inputs produce pairs. These have found false, a not_found status and an English explanation.
A quote-only token, unknown address or unsupported chain may all produce the same missing
result. A run with no pairs returns an empty result with a not_found explanation.

### Example output

A real row for the dogwifhat token on Solana, taken from the input above (a selection of the flat
fields; the full row also carries the activity windows and the original source objects):

```json
{
  "symbol": "$WIF",
  "exchange": "orca",
  "chain": "solana",
  "pair_address": "D6NdKrKNQPmRZCCnG1GqXtF7MMoHB7qR6GU5TkG59Qz1",
  "base_symbol": "$WIF",
  "quote_symbol": "SOL",
  "price": 0.1795,
  "price_native": 0.001778,
  "liquidity_usd": 138749.45,
  "fdv": 179316768,
  "market_cap": 179316768,
  "pair_created_at": "2024-05-18T20:45:47.000Z",
  "volume_h24": 224938.46,
  "price_change_h24": 0.2,
  "buys_h24": 3433,
  "sells_h24": 3528
}
```

An address that cannot be resolved becomes a diagnostic row instead of disappearing:

```json
{
  "found": false,
  "status": "not_found",
  "input": "0x0000000000000000000000000000000000000bad",
  "chain": "ethereum",
  "pair_address": null,
  "message": "Address 0x0000000000000000000000000000000000000bad not found on chain ethereum (unknown address, quote-only token or unsupported chain)"
}
```

### Use cases

- **Trading bots and alerts.** Refresh the price, liquidity and buy/sell counts of a watchlist of
  token addresses on a schedule and trigger your own logic when liquidity drops or volume jumps.
- **Portfolio and price dashboards.** Feed a spreadsheet, database or BI tool with DEX prices in
  USD and in the quote token, one row per pair, with the chain kept for joins.
- **New-token research.** Turn the latest token profiles or the top boosted tokens into pair rows
  and filter on pool age, liquidity and market cap before looking at a token by hand.
- **Due diligence on a token.** Collect the websites and social links from the token profile next
  to the trading data, and compare the pools of one token with `all_pairs`.
- **Data pipelines.** The core fields follow a generic price-snapshot shape (symbol, exchange,
  price, currency, asset class `crypto`), so crypto rows can sit next to other market data.

### How this compares to other DexScreener scrapers on the Store

- **Addresses in, rows out.** Many DexScreener actors crawl the screener tables and rank tokens.
  This one is built for lookups: you give symbols, token addresses or pair addresses and get
  exactly those pairs, up to three hundred addresses per input list in one run.
- **No wasted rows.** Addresses that do not resolve come back as free diagnostic rows, so you see
  which input failed without paying for it.
- **Original and flat fields together.** You get ready-to-use columns for CSV and Excel plus the
  original DexScreener objects for existing integrations.
- **Pay per pair.** You pay for delivered pairs only, with no separate start fee. See Pricing.
- **Not included.** Trending screener filters, historical candles, wallet holdings and
  transaction logs are outside this actor.

### Pricing

The pair event counts only delivered rows with a populated pair_address. Missing-address
diagnostics and failed-input rows do not count as pairs. This actor does not request a separate
start event. Consult the actor's current Pricing tab for the event rate and Apify platform
usage costs. The free-plan delivery limit is ten dataset rows per run; diagnostic rows can
occupy positions within that delivery limit while remaining outside the pair-event count.
The output limit controls volume, not the price of each event.

### Limits and partial results

Search results and token pools have source limits; this actor does not expose the website's
trending screener, ranking filters, historical candles, wallet holdings or transaction logs.
When an input fails alongside successful inputs, delivered pairs are retained and partial
results include warnings. If max_items omits additional pairs, the run also reports that
limit. Review the OUTPUT record for counts and warnings before treating a dataset as complete.
For recurring snapshots, schedule separate runs and keep their retrieval timestamps.

### FAQ

#### Does a token lookup return its most liquid pool?

It returns the main pool chosen by DexScreener. Use all_pairs to compare the returned base-token
pools yourself. Source limits still apply, so the result is not a promise of every existing pool.

#### Can I combine several chains in one run?

Yes. Prefix individual token or pair addresses with their chain ID. Search results may also
contain multiple chains. Keep the chain field when joining rows, since an address alone is
not a unique identifier across every chain.

#### Why are some values missing or an address not found?

Source coverage varies. A new pool may lack liquidity statistics or a profile. Some tokens
appear only as quote assets, and unknown chains and addresses can return no pairs. The actor
preserves missing values and reports diagnostics rather than creating estimates.

#### Are boosts trading recommendations?

Boost fields describe the selected source feed. They do not establish token quality, safety,
future performance or liquidity. Use them as dataset attributes when comparing snapshots.

# Actor input Schema

## `queries` (type: `array`):

Search terms, token names, symbols, addresses or pair notation such as SOL/USDC. Blank strings are ignored. Maximum 30 source pairs per query.

## `token_addresses` (type: `array`):

Token addresses in address or chain:address form. Without a prefix, chain is used. Default: DexScreener-selected main pair per token.

## `pair_addresses` (type: `array`):

Pair addresses in address or chain:address form. Without a prefix, chain is used.

## `feeds` (type: `array`):

Optional token feeds: latest_profiles, top_boosts, latest_boosts. Tokens are resolved to main pairs; duplicate feed tokens are removed.

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

Default lowercase chain ID for unprefixed addresses, e.g. solana, ethereum, bsc or base. Other chain IDs are accepted.

## `all_pairs` (type: `boolean`):

Resolve up to 30 pools for each explicit token address instead of its selected main pair. Maximum 20 token addresses. Only pools with the requested token as base token are returned. Feeds always resolve main pairs.

## `max_items` (type: `integer`):

Maximum unique pair rows across the run. Diagnostic rows do not count toward this limit. Narrow inputs if more than 40 upstream requests are required.

## Actor input object example

```json
{
  "queries": [],
  "token_addresses": [],
  "pair_addresses": [],
  "feeds": [],
  "chain": "solana",
  "all_pairs": false,
  "max_items": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One row per unique pair, plus diagnostics for missing addresses or failed inputs.

## `output` (type: `string`):

Counts, partial flag and warnings.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("s-r/dexscreener-scraper").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 '{}' |
apify call s-r/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/dexscreener-scraper"
        }
    }
}
```

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/lxAPDA3iDO1DIVuIf/builds/otYnPaZrE93IBRvVT/openapi.json