# DexScreener Pairs Scraper (`axiomworks/dexscreener-pairs-scraper`) Actor

Collect public DexScreener trading pairs and return one dataset item per distinct pool. Records include chain, exchange, token addresses, prices, liquidity, volume, price changes and pair URLs. Search across chains, look up known tokens or pairs, or use public discovery lists without an API key.

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

## Pricing

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

## DexScreener Pairs Scraper

**Returns:** one row per trading pair with `chainId`, `dexId`, `pairAddress`, `baseTokenSymbol`, `priceUsd`, `liquidityUsd`, and `volume24h`.
**Input:** `{"searchQueries":["WETH"],"maxItems":10}`
**Best for:** token pool lookups, pair comparisons, and scheduled market snapshots.

```json
{"id":"solana:hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef","chainId":"solana","dexId":"orca","baseTokenSymbol":"WETH","priceUsd":2503.79,"liquidityUsd":7174833.03,"volume24h":3620702.25}
```

### What does DexScreener Pairs Scraper do?

DexScreener Pairs Scraper extracts public trading pair data from the DexScreener JSON API. Give it a token symbol or name, a token address, or a pair URL. It returns one dataset item for each distinct trading pair. You can also select a public discovery list to find current token profiles, boosts, or community takeovers and then collect the associated pairs. No login is required.

The Actor is useful when you need a structured snapshot of pools across chains. A search for a ticker can return pairs for unrelated tokens that share that ticker, so the output keeps the chain, token addresses, exchange identifier, and pair address alongside market figures. You can restrict chains or set minimum liquidity and daily volume to narrow the result. The Actor does not decide which token is authentic, recommend a trade, or track subsequent changes after the run.

It calls the API directly and does not open the DexScreener website. The values are a snapshot at collection time; prices, volume, and liquidity can change quickly. Each result includes its collection timestamp so downstream systems can judge how recent the data is. This Actor is independently built and is not affiliated with DexScreener.

### What data can you get?

Each row represents one pair. The default overview shows the token, chain, exchange, price, liquidity, daily volume, daily price change, valuation, age, and pair URL. The complete dataset has more columns. Optional fields are `null` when the API omits them, while arrays such as labels and websites can be empty. Numeric prices are converted from the API's string values to numbers; absent values are never converted to zero.

| Field | Meaning |
| --- | --- |
| `id`, `sourceUrl`, `pairUrl` | Stable chain and pair identifier and the public pair URL |
| `chainId`, `dexId`, `pairAddress` | Blockchain, exchange, and pool address |
| `baseTokenAddress`, `baseTokenName`, `baseTokenSymbol` | Base asset identity |
| `quoteTokenAddress`, `quoteTokenName`, `quoteTokenSymbol` | Quote asset identity |
| `priceUsd`, `priceNative` | Base asset price in USD and quote currency |
| `liquidityUsd`, `liquidityBase`, `liquidityQuote` | Pool liquidity in USD and token amounts |
| `fdv`, `marketCap` | Fully diluted valuation and reported market capitalization |
| `volume24h`, `volume6h`, `volume1h`, `volume5m` | Volume for four rolling windows |
| `priceChange24h`, `priceChange6h`, `priceChange1h`, `priceChange5m` | Percent price changes for those windows |
| `buys24h`, `sells24h`, `txns` | Daily buy and sell counts and the API's windowed counts |
| `pairCreatedAt`, `pairAgeHours` | Pair creation time and approximate age when collected |
| `labels`, `boostsActive`, `boostTotalAmount` | Pool labels and available boost data |
| `imageUrl`, `headerImageUrl`, `websites`, `socials` | Optional token profile media and links |
| `twitter`, `telegram`, `discord` | First matching social link of each type, when supplied |
| `tokenDescription` | Optional description from a discovery entry |
| `inputSource`, `scrapedAt` | Input that found the pair and collection time |

`id` is built from the chain and normalized pair address. The Actor removes duplicate IDs across all supplied inputs. The same pool found through a search and a pair URL appears once. Profile links, images, and descriptions are only present when the upstream response supplies them. The Actor copies those values without visiting their destinations. Trading counts and changes may be absent for quiet pools or short-lived pairs.

### How to use

Enter one or more search queries to find pairs by token name, ticker, pair name, or address. Search is broad: a ticker may match many different assets. For a known contract, provide a chain-qualified token address so the Actor requests that token's pools. For a known pool, provide its DexScreener URL or `chainId/pairAddress`. A DexScreener search URL with a `q` parameter can be supplied in `startUrls` and is treated as a search query.

You can combine input methods. The Actor gathers pair responses, filters them, removes duplicates, applies a per-token pool cap if requested, optionally sorts the remaining records, and then applies `maxItems`. Results are charged only when written to the dataset. The API has no pagination for these endpoints: a single search or token request returns up to 30 pairs. Add more queries or addresses to cover more pools. Pair-address lookups are batched by chain, with up to 30 addresses per API call.

Use `chainIds` when a ticker exists on several networks and `dexIds` to select exchanges. Liquidity, 24-hour volume, FDV, market cap, and pair-age thresholds narrow the returned pairs; a positive threshold excludes pairs without that metric. Set `maxPairsPerToken` to `1` to retain the most liquid pool for each base token on each chain. With `sortBy: "none"`, records follow API and input order, and fetching stops when `maxItems` unique matches are found. Sorted or per-token-capped runs collect all requested responses before selecting output. A failed individual request is recorded in the run summary, and other inputs can still produce results.

### Input

The Console form groups lookup fields, filters, and advanced settings. At least one lookup or a discovery mode is useful. If every lookup is empty and discovery is `none`, the Actor warns and searches `WETH` so an empty API input still produces a usable sample. This fallback is meant for an initial run; specify your own target for repeatable work.

| Input | Description and default |
| --- | --- |
| `searchQueries` | Text searches; Console prefill is `WETH`. Each term can return up to 30 pairs. |
| `tokenAddresses` | Token contracts as `chainId:address`, `chainId/address`, a DexScreener token URL, or a bare address. |
| `pairUrls` | Pair URLs or `chainId/pairAddress` strings. The runtime also accepts URL objects. |
| `startUrls` | Legacy URL-object list with a `url` property; the runtime also accepts strings. Search URLs with `q` are supported. |
| `defaultChainId` | Chain to use for a bare token address. Without it, the Actor searches the address and checks an exact token-address match. |
| `discover` | `none`, `latestProfiles`, `latestBoosts`, `topBoosts`, or `communityTakeovers`; default `none`. |
| `chainIds` | Optional chain filter; empty means any chain. |
| `dexIds` | Optional DEX identifier filter; empty means any DEX. |
| `minLiquidityUsd` | Minimum liquidity in USD; default `0`. |
| `maxLiquidityUsd` | Maximum liquidity in USD; `0` disables the filter. |
| `minVolume24hUsd` | Minimum daily volume in USD; default `0`. |
| `minMarketCapUsd`, `maxMarketCapUsd` | Inclusive reported market-cap bounds in USD; `0` disables either bound. |
| `minPairAgeHours`, `maxPairAgeHours` | Inclusive pair-age bounds in hours; `0` disables either bound. |
| `maxPairsPerToken` | Most liquid pools retained per base token; `0` keeps all, and is the default. |
| `minFdvUsd`, `maxFdvUsd` | Inclusive FDV bounds; `0` disables each. Missing FDV fails an enabled bound. |
| `sortBy` | `none`, `liquidityUsd`, `volume24h`, `priceChange24h`, `pairCreatedAt`, `fdv`, `marketCap`, or `boostsActive`; default `none`. |
| `maxItems` | Maximum distinct output rows, from 1 to 5000; default `50`. The Console prefill is `10`. |
| `proxyConfiguration` | Optional Apify Proxy configuration; disabled by default. |

Here is an input for pools matching two tickers on Solana, with minimum liquidity and a strict result limit:

```json
{
  "searchQueries": ["BONK", "WIF"],
  "chainIds": ["solana"],
  "minLiquidityUsd": 10000,
  "sortBy": "liquidityUsd",
  "maxItems": 20
}
```

For a known token, `{"tokenAddresses":["solana:JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"],"maxItems":7}` requests its pools and returns no more than seven rows. For a known pair, a `pairUrls` string can contain the full public pair URL. If a supplied pair address is actually a token address, the Actor tries the token-pairs endpoint as a fallback. Malformed entries are skipped with a warning. An unknown chain or dead search term does not create an error row.

### Output

A local run with the `WETH` prefill produced the item below. Market values reflect that run and are examples of structure, not current quotes. The live dataset contains additional optional columns described above. The `sourceUrl` and `pairUrl` values refer to the public pair page, while `inputSource` identifies which input found it.

```json
{
  "id": "solana:hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef",
  "sourceUrl": "https://dexscreener.com/solana/hktfl7iwgkt5qhjywqkcdnzxscoh811k7akrmzjkccef",
  "chainId": "solana",
  "dexId": "orca",
  "pairAddress": "HktfL7iwGKT5QHjywQkcDnZXScoh811k7akrMZJkCcEF",
  "baseTokenName": "Wrapped Ether (Wormhole)",
  "baseTokenSymbol": "WETH",
  "quoteTokenSymbol": "SOL",
  "priceUsd": 2503.79,
  "liquidityUsd": 7174833.03,
  "volume24h": 3620702.25,
  "priceChange24h": -0.08,
  "pairCreatedAt": "2022-11-28T02:25:41.000Z",
  "inputSource": "search:WETH",
  "scrapedAt": "2026-10-11T15:34:08.502Z"
}
```

The default dataset is the main output. The key-value store also contains `RUN_SUMMARY`, with the number of API inputs processed, pairs found before filtering, rows pushed, and request errors. When a lookup has no matches, the run succeeds with an empty dataset, logs a warning, and sets a status message naming the inputs and what to change. If the API returned pairs but filters removed them, relax chainIds, dexIds or numeric bounds. If no pairs were found, check the chain and contract or pair address, or try another token symbol. Request failures also direct you to RUN_SUMMARY.errors; retry later or enable Apify Proxy for persistent IP blocks. A hidden verification input saves evidence to `SNAPSHOTS` for the first ten rows. API fields retain the raw pair object; `inputSource` retains the lookup label derived from the input, and `scrapedAt` retains the Actor's collection timestamp. Those two values are Actor metadata rather than DexScreener API fields. Snapshots are for source auditing rather than normal integration output.

### How much does it cost?

The Actor is charged per result written to the dataset. A lookup that produces zero rows does not generate result events, and a limit of seven can charge for at most seven results. The number of upstream API responses may be larger than the output count because filtering, deduplication, sorting, and `maxItems` are applied before records are pushed. Consult the Actor's Pricing tab for the current charge information and billing terms. No separate enrichment step is used.

### Use with AI agents (MCP)

An AI agent can use the Actor through Apify MCP to request structured pair data. Configure the MCP server for this Store path:

```text
https://mcp.apify.com/?tools=axiomworks/dexscreener-pairs-scraper
```

Ask for a precise target and a bounded result count. For example, an agent can request: “Find up to seven Solana pairs matching WIF, sorted by liquidity, and include their pair addresses and 24-hour volume.” Another prompt can be: “Look up the pools for this chain-qualified token contract and return the most liquid pool with its source URL.” The response is suitable for comparison or monitoring workflows, but the agent should account for the data's collection time and should not treat matching symbols alone as identity proof.

The first input fields exposed to agents are the lookup fields, followed by filters and the item limit. Required values can be sent explicitly in the tool call. If an agent supplies no target, the Actor uses its documented WETH sample fallback. A narrow chain filter and an address are more reliable when a symbol is shared by multiple tokens. The `id` field lets an agent merge repeated runs without treating the same pair as a new asset.

### Integrations and API

Use the dataset URL from a completed run to import rows into a spreadsheet, database, alerting workflow, or another Actor. The Apify API can start a run and return its dataset items. Replace `APIFY_TOKEN` in the following examples with your own authenticated client configuration; keep tokens in your secret manager. The examples use a bounded search to keep the response predictable.

Python with the Apify client:

```python
import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/dexscreener-pairs-scraper").call(
    run_input={"searchQueries": ["WETH"], "maxItems": 7}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["id"], item.get("liquidityUsd"))
```

JavaScript with the Apify client:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/dexscreener-pairs-scraper').call({
    searchQueries: ['WETH'], maxItems: 7,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) process.stdout.write(`${item.id}\n`);
```

A cURL request to the synchronous dataset endpoint:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/axiomworks~dexscreener-pairs-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"searchQueries":["WETH"],"maxItems":7}'
```

For repeated use, store the token outside scripts and use your environment or platform secret settings. The dataset may contain several pools with the same base symbol. Match by chain and contract address when joining to other records. If you want a stable sample size across runs, remember that an endpoint can return fewer than the requested maximum after filters or because fewer matching pools exist.

### FAQ

**Why do I see unrelated tokens for a symbol?** Search matches public names and tickers across chains. A symbol is not a unique asset identifier. Inspect `baseTokenAddress`, `quoteTokenAddress`, `chainId`, and `pairAddress`, or use a known contract address as input.

**Why did my query produce fewer rows than `maxItems`?** The API may return fewer than 30 pairs for one search, and filtering or deduplication can reduce that count. Add another query or address to broaden coverage. `maxItems` is a ceiling, not a minimum.

**Can I request every pair on DexScreener?** The documented lookup endpoints have no page cursor. Search and token calls are capped by the upstream response. This Actor combines multiple inputs, but it cannot enumerate all pairs from a single query.

**Why are profile fields empty?** Image, website, social, and discovery description fields depend on upstream token profile data. Pools without that data have empty or null values. The Actor does not guess missing links.

**What happens when the API rate limits a request?** The Actor retries block and server responses with delays. If a request still fails, it logs the failure and records it in `RUN_SUMMARY`; other inputs continue. Users who need another exit IP can configure Apify Proxy in advanced input.

**Is the output historical?** No. Market metrics are the API's current snapshot at request time. `pairCreatedAt` describes the pair's creation, while `scrapedAt` describes when this run collected the row. Store successive run outputs yourself if you need a time series.

### Is it legal to scrape DexScreener?

The Actor reads public JSON API responses and does not access an account, private data, or protected pages. Whether a particular use is lawful depends on your location, the data, and how you use the output. Review the applicable terms and rules for your use case, keep requests modest, and respect people whose information appears in optional profile links. The Actor does not imply endorsement or affiliation with DexScreener. It does not execute URLs found in token profiles or contact their destination hosts.

### Feedback

If a pair lookup returns an unexpected pool, include the input, the chain and pair address, the run status, and the `RUN_SUMMARY` error list when reporting it through the Actor's Store feedback channel. Avoid posting API tokens or other secrets. Concrete examples help distinguish a parsing issue from an upstream change or a shared ticker. For missing market fields, compare the pair's public API response with the output at the same collection time, since market data changes rapidly. Feature requests are most useful when they describe the exact input and output field needed.

# Actor input Schema

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

Search strings, e.g. \["WETH"] or \["SOL/USDC"]. Each query returns up to 30 pairs across chains. Empty target lists with discover="none" fall back to WETH.

## `tokenAddresses` (type: `array`):

Token contracts, e.g. \["ethereum:0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]. Accept chainId:address, chainId/address, DexScreener URLs or bare addresses. Bare addresses use defaultChainId, or exact address search when it is empty.

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

Pair locators, e.g. \["ethereum/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640"], full https://dexscreener.com/{chain}/{address} URLs, or {"url":"..."} objects. Token addresses in this field fall back to token pool lookup.

## `startUrls` (type: `array`):

Legacy alias for pairUrls; accepts strings or {"url":"https://dexscreener.com/?q=WETH"} objects. Pair URLs look up pools; /?q= and /search?q= URLs run text searches. Default \[].

## `defaultChainId` (type: `string`):

Chain ID for bare token addresses, e.g. "ethereum", "solana", "base" or "bsc". Default "" uses exact address search; qualified addresses keep their own chain.

## `discover` (type: `string`):

Discovery mode: "none", "latestProfiles", "latestBoosts", "topBoosts" or "communityTakeovers". Example: "topBoosts" looks up pools for currently boosted tokens. Default "none".

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

Chain IDs to retain, e.g. \["solana","ethereum"]. Case-insensitive; default \[] keeps every chain.

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

Exchange IDs to retain, e.g. \["uniswap","raydium"]. Case-insensitive; default \[] keeps every exchange.

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

Minimum inclusive liquidity in USD, e.g. 10000. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `maxLiquidityUsd` (type: `number`):

Maximum inclusive liquidity in USD, e.g. 1000000. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `minVolume24hUsd` (type: `number`):

Minimum inclusive 24-hour trading volume in USD, e.g. 10000. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `minMarketCapUsd` (type: `number`):

Minimum inclusive reported market capitalization in USD, e.g. 1000000. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `maxMarketCapUsd` (type: `number`):

Maximum inclusive reported market capitalization in USD, e.g. 100000000. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `minPairAgeHours` (type: `number`):

Minimum inclusive pair age in hours, e.g. 24. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `maxPairAgeHours` (type: `number`):

Maximum inclusive pair age in hours, e.g. 168. Nonnegative number; default 0 disables this bound. A positive bound excludes pairs missing this metric.

## `maxPairsPerToken` (type: `integer`):

Maximum pools per base token on each chain, e.g. 1 keeps the most liquid pool. Nonnegative integer; default 0 keeps all returned pools. Applied before maxItems.

## `sortBy` (type: `string`):

Descending sort by none (API order), liquidityUsd, volume24h, priceChange24h, pairCreatedAt, fdv, marketCap or boostsActive. Default none. Sorting applies to collected pairs before the shared maxItems limit; missing values sort last.

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

Maximum unique trading pairs to return, integer 1-5000, default 50. Example: 10 returns at most ten pairs after filters and deduplication; fewer when fewer match. One query returns at most 30 API pairs.

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

Proxy settings, e.g. {"useApifyProxy":false} (default). Set {"useApifyProxy":true} to use Apify Proxy when your IP is blocked or rate-limited; retries use fresh sessions.

## `minFdvUsd` (type: `number`):

Minimum inclusive FDV in USD, e.g. 1000000. Default 0 disables this bound; positive bounds exclude pairs without fdv. Applies to returned API pairs, not a sitewide search.

## `maxFdvUsd` (type: `number`):

Maximum inclusive FDV in USD, e.g. 1000000. Default 0 disables this bound; positive bounds exclude pairs without fdv. Applies to returned API pairs, not a sitewide search.

## Actor input object example

```json
{
  "searchQueries": [
    "WETH"
  ],
  "tokenAddresses": [],
  "pairUrls": [],
  "startUrls": [],
  "defaultChainId": "",
  "discover": "none",
  "chainIds": [],
  "dexIds": [],
  "minLiquidityUsd": 0,
  "maxLiquidityUsd": 0,
  "minVolume24hUsd": 0,
  "minMarketCapUsd": 0,
  "maxMarketCapUsd": 0,
  "minPairAgeHours": 0,
  "maxPairAgeHours": 0,
  "maxPairsPerToken": 0,
  "sortBy": "none",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "minFdvUsd": 0,
  "maxFdvUsd": 0
}
```

# Actor output Schema

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

Scraped trading pairs

## `summary` (type: `string`):

Input and output counts and errors

# 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": [
        "WETH"
    ],
    "discover": "none",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/dexscreener-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 = {
    "searchQueries": ["WETH"],
    "discover": "none",
    "maxItems": 10,
}

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

```

## MCP server setup

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