# DEX Screener Token Pairs Scraper (`fetch_cat/dexscreener-token-pairs-scraper`) Actor

Export DEX Screener token pair snapshots for symbols, addresses, chains, prices, liquidity, volume, websites, and socials.

- **URL**: https://apify.com/fetch_cat/dexscreener-token-pairs-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 result 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?

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

Search DEX Screener by token symbol, name, pair name, token address or pair address and export token-pair snapshots. Get chain and exchange identifiers, prices, liquidity, trading activity and available website/social links in an Apify dataset.

This is a search snapshot, not an exhaustive pool lookup, historical price feed or continuous trading monitor. Search coverage and ordering come from DEX Screener. The Actor does not rank pairs by liquidity or volume.

### Quick start

1. Add one or more **Token queries**, such as `SOL/USDC` or `WETH`.
2. Optionally choose chain IDs, then set a small maximum pairs per query.
3. Start the Actor and download the dataset as JSON, CSV or Excel, or retrieve it through the API.

```json
{
  "queries": ["SOL/USDC"],
  "chainIds": ["solana"],
  "maxResultsPerQuery": 10,
  "includeWebsitesAndSocials": true
}
```

A symbol can match unrelated tokens. Verify token and pair addresses before using the results for research or decisions.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### What you get

One snapshot row per unique chain, exchange and pair combination, with token identities, source links and available prices, liquidity and activity fields. The first query that saves a pair remains its `query`. Optional market values can be null, and enabled project-link arrays can be empty.

### Who is it for?

- **Token-market researchers** inspecting a bounded sample of public pair data.
- **Data analysts** comparing available liquidity and activity fields across their own snapshots.
- **Research teams** checking token and pair identities before interpreting symbol matches.
- **Data engineers** adding public pair observations to a spreadsheet or reporting workflow.

### How you can use the data

- **Inspect a Solana SOL/USDC sample.** Use the existing query and chain filter with a small per-query cap. Keep `chainId`, `dexId`, `pairAddress`, token addresses and `fetchedAt` beside price and liquidity values so every observation has an identity and collection time.
- **Prepare an Ethereum research sheet.** Search `WETH` and `USDC` on `ethereum`. Compare available `priceUsd`, `liquidityUsd`, `txns` and `volume` fields within the returned sample. Overlapping pairs are saved once, and this does not rank all Ethereum pools.
- **Check symbol ambiguity.** Review base and quote token addresses and the source pair link before grouping results by symbol. A shared name alone does not establish that two records describe the same token.
- **Compare separate observations downstream.** Match chain, exchange and pair identifiers across your own dated exports. This is a separate comparison step, not historical candles, continuous monitoring or trading execution.

### Input settings

**Cross-chain token research:** search for a symbol without a chain filter.

```json
{"queries":["USDC"],"maxResultsPerQuery":10}
```

**A small Ethereum watchlist:** collect up to five pairs per query. Overlapping pairs are saved only once across the run.

```json
{"queries":["WETH","USDC"],"chainIds":["ethereum"],"maxResultsPerQuery":5}
```

These are input recipes, not links to public saved tasks.

#### More input settings

| Setting / API key | Default | What it does |
| --- | --- | --- |
| Token queries — `queries` | Required | Non-empty list of symbols, names, pairs or addresses to search. |
| Filter by chain IDs — `chainIds` | No filter | Keep matching chain IDs, case-insensitively. The form initially suggests `solana` and `ethereum`. Clear them for all returned chains. |
| Maximum pairs per query — `maxResultsPerQuery` | `30` | Save at most 1–100 pairs per query after filtering and removing duplicates. Form example: `10`. |
| Include websites and socials — `includeWebsitesAndSocials` | `true` | Include available project links. When false, omit `websites` and `socials`. |
| Delay between queries — `requestDelayMs` | `250` | Requested delay in milliseconds. See the field help for the effective minimum. |
| Proxy configuration — `proxyConfiguration` | Proxy disabled | Optional existing proxy settings. No proxy is enabled automatically when a request fails. |

### Output data

Each row is one unique chain/exchange/pair combination. The `query` is the first query that saved that pair. The following abbreviated example illustrates the shape only. It is not a market observation:

```json
{
  "query": "WETH",
  "chainId": "ethereum",
  "dexId": "uniswap",
  "pairAddress": "<pair address>",
  "baseToken": {"address":"<token address>","name":"<token name>","symbol":"WETH"},
  "quoteToken": {"address":"<quote address>","name":"<quote name>","symbol":"USDC"},
  "priceUsd": null,
  "liquidityUsd": null,
  "websites": [],
  "socials": []
}
```

| Fields | Meaning |
| --- | --- |
| `query`, `chainId`, `dexId`, `pairUrl`, `pairAddress` | Search and pair identity. |
| `baseToken`, `quoteToken` | Token objects with `address`, `name` and `symbol`. |
| `priceNative`, `priceUsd` | Price strings, or `null` when unavailable. |
| `txns`, `volume`, `priceChange` | Available time-window activity objects. Not historical candles. |
| `liquidityUsd`, `liquidityBase`, `liquidityQuote`, `fdv`, `marketCap` | Numeric market values or `null`. |
| `pairCreatedAt`, `pairCreatedAtTimestamp` | Pair creation time as ISO text and the original timestamp, when available. |
| `labels`, `fetchedAt` | Available labels and the query snapshot timestamp. |
| `websites`, `socials` | Optional arrays of project links. Empty when enabled but unavailable. |

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

Pay-per-event pricing uses a one-time `start` charge and a `result` event for each saved token-pair row. A search with no saved pairs produces no result events, but the start charge still applies. Error and status rows are not saved as pair results.

Keep the query list short and the per-query cap small. See the [live Pricing tab](https://apify.com/fetch_cat/dexscreener-token-pairs-scraper/pricing) for current rates and discounts.

### Tips for best results

- **Verify addresses before interpreting symbols.** Keep base-token, quote-token and pair addresses with your analysis.
- **Review the form's chain suggestions.** Clear suggested chains when you want all chains returned by the source, or choose the exact chain IDs your research needs.
- **Start with a small per-query cap.** Later queries can return fewer new rows because pairs are deduplicated across the run.
- **Keep missing values distinct from zero.** Prices can be strings or null, and absent liquidity or activity does not establish inactivity.
- **Inspect the outcome before combining snapshots.** Check the run log and `RUN_SUMMARY` for partial work or failures.

### Limits and caveats

Search coverage and ordering come from DEX Screener. The result cap is a ceiling: the search can return fewer matches, chain filters can remove them and duplicate pairs are not saved again for later queries. Raising the cap does not fetch additional pages. This is not an exhaustive pool lookup or a liquidity- or volume-ranked result set.

Missing metadata is returned as null, empty arrays or omitted optional fields as described in Output data. Project links are omitted when their input switch is off. No matches or no usable pairs produce an empty dataset. Request or essential storage failures can fail the run.

A run approaching its deadline can preserve partial results. Check its log and `RUN_SUMMARY` before treating an export as complete.

No DEX Screener login or API key is needed. Private data, wallet holdings, historical candles, continuous monitoring and trading execution are not supported. This independent Actor is not affiliated with DEX Screener and does not provide financial advice.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~dexscreener-token-pairs-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "queries": [
    "SOL/USDC"
  ],
  "chainIds": [
    "solana"
  ],
  "maxResultsPerQuery": 10,
  "includeWebsitesAndSocials": true
}
JSON
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/dexscreener-token-pairs-scraper').call({
  "queries": [
    "SOL/USDC"
  ],
  "chainIds": [
    "solana"
  ],
  "maxResultsPerQuery": 10,
  "includeWebsitesAndSocials": true
});
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('fetch_cat/dexscreener-token-pairs-scraper').call(run_input={'queries': ['SOL/USDC'], 'chainIds': ['solana'], 'maxResultsPerQuery': 10, 'includeWebsitesAndSocials': True})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP and AI agents

You can ask your AI assistant to collect data with **DEX Screener Token Pairs Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **DEX Screener Token Pairs Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/dexscreener-token-pairs-scraper"
    }
  }
}
```

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **DEX Screener Token Pairs Scraper** by Fetch Cat, or give it the identifier `fetch_cat/dexscreener-token-pairs-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Use Fetch Cat’s DEX Screener Token Pairs Scraper to collect up to 5 SOL/USDC pairs on Solana. Show token addresses, pair addresses, source links and available prices and liquidity, marking missing values.”
- “Collect at most 5 pairs per query for WETH and USDC on Ethereum. Keep exchange identifiers and snapshot times with the activity fields, without ranking the sample as all available pools.”
- “Retrieve up to 3 USDC search matches across returned chains with the form's chain suggestions cleared. Show base and quote token addresses so I can check unrelated tokens sharing the same symbol.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/dexscreener-token-pairs-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Why is a symbol missing or matched to another token?

Search coverage is controlled by DEX Screener. Try the token address, check your chain filter and verify the returned addresses. An address search is not a guarantee of every pool for that token.

#### Can I get the top pairs by volume?

There is no sorting input. You can sort the returned dataset yourself, but it remains a bounded search sample.

#### Can I use this as a price history feed?

No. Each run returns available snapshots, not a historical candle series or a built-in alerting service.

### Related Actors

- [CoinMarketCap Crypto Prices Scraper](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper) — broader cryptocurrency market snapshots.
- [TradingView Screener Scraper](https://apify.com/fetch_cat/tradingview-screener-scraper) — market screening research.
- [Yahoo Finance Stock Data Scraper](https://apify.com/fetch_cat/yahoo-finance-stock-data-scraper) — adjacent stock-market data research.
- [Stocktwits Scraper](https://apify.com/fetch_cat/stocktwits-scraper) — public market discussion research.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) — news context for a research workflow.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/dexscreener-token-pairs-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/dexscreener-token-pairs-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

This Actor's version history is a separate document: https://apify.com/fetch_cat/dexscreener-token-pairs-scraper/changelog.md

# Actor input Schema

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

Add at least one non-empty token symbol, name, pair name, token contract address or pair address. Every entry is a DEX Screener search, not an exhaustive lookup of all pools for an address. Results keep the search service's order.

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

Optional DEX Screener chain IDs to keep, for example solana, ethereum, base, bsc, polygon, arbitrum. Leave empty to include all chains returned by the search.

## `maxResultsPerQuery` (type: `integer`):

Save up to this many pairs for each query after chain filtering and run-wide duplicate removal. Omitted API input defaults to 30; the form suggests 10. Range: 1–100. This does not fetch more search pages or guarantee that many matches.

## `includeWebsitesAndSocials` (type: `boolean`):

Enabled by default. Include website and social arrays from available pair metadata; missing links produce empty arrays. When disabled, omit these two fields. No separate project-profile lookup is performed.

## `requestDelayMs` (type: `integer`):

Requested delay between queries, in milliseconds. Default 250; accepted form range 0–10000. An effective minimum of 200 milliseconds still applies when a lower value is entered. This is not a total runtime limit.

## `proxyConfiguration` (type: `object`):

Optional explicit proxy settings for requests from the start. Proxy use is disabled by default; omission makes direct requests. Existing customer proxy URLs, managed Apify settings and explicit opt-outs remain supported through this field. There is no automatic switch to a proxy after a failed direct request. Managed proxies may incur platform charges. Do not share proxy URLs or credentials in support reports.

## Actor input object example

```json
{
  "queries": [
    "SOL/USDC",
    "WETH"
  ],
  "chainIds": [
    "solana",
    "ethereum"
  ],
  "maxResultsPerQuery": 10,
  "includeWebsitesAndSocials": true,
  "requestDelayMs": 250,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "queries": [
        "SOL/USDC",
        "WETH"
    ],
    "chainIds": [
        "solana",
        "ethereum"
    ],
    "maxResultsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/dexscreener-token-pairs-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 = {
    "queries": [
        "SOL/USDC",
        "WETH",
    ],
    "chainIds": [
        "solana",
        "ethereum",
    ],
    "maxResultsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/dexscreener-token-pairs-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 '{
  "queries": [
    "SOL/USDC",
    "WETH"
  ],
  "chainIds": [
    "solana",
    "ethereum"
  ],
  "maxResultsPerQuery": 10
}' |
apify call fetch_cat/dexscreener-token-pairs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/dexscreener-token-pairs-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/aWiPm1pMVc6o4TIS1/builds/VKtlI2GgL1EdI0A6d/openapi.json
