# DexScreener Crypto Scraper | Token Data API (`parsebird/dexscreener-crypto-scraper`) Actor

Extract DexScreener token data: prices, liquidity, market cap, volume, transactions, FDV, pair URLs, socials. Filter, schedule, use API, export JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/dexscreener-crypto-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Automation, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.39 / 1,000 token scrapeds

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Crypto Scraper

DexScreener Crypto Scraper extracts **DexScreener token data** from [DexScreener](https://dexscreener.com/) by blockchain or chain/DEX segment, including token prices, liquidity, market cap, FDV, volume, transaction counts, pair URLs, images, websites, and socials.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Scrape DexScreener data for Solana, Ethereum, BSC, Base, Polygon, and other supported chains with filters, scheduling, API access, and JSON, CSV, or Excel export.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```text
Use Apify Actor parsebird/dexscreener-crypto-scraper to scrape DexScreener token data. Call ApifyClient(token).actor("parsebird/dexscreener-crypto-scraper").call(run_input={"chainName":"solana","time":"24h","rankBy":"trendingScoreH24","order":"desc","fromPage":1,"toPage":1,"limit":10,"limitPerPage":10,"filterArgs":[],"addTokenDetails":false,"addTopTraders":false,"topTradersTimeframe":"7d"}). Key inputs: chainName string required; time 24h/6h/1h/5m; rankBy sort field; order desc/asc; numeric min/max filters; filterArgs raw DexScreener query strings; limits and page range; addTokenDetails boolean. Output: tokenName, tokenSymbol, chainId, dexId, address, lowerPoolAddress, priceUsd, price changes, volumeUsd, transactionCount, liquidityUsd, marketCapUsd, fdvUsd, pairDetailUrl, tokenImageUrl, websites, socials. API docs: https://docs.apify.com/api/client/python/ and token setup: https://console.apify.com/account/integrations.
````

### What is DexScreener Crypto Scraper?

DexScreener Crypto Scraper is a **DexScreener scraper and DexScreener API alternative** for exporting token and pair data into an Apify dataset. It uses verified public DexScreener API responses where available, then applies filters, sorting, pagination, and optional token detail enrichment inside the Actor.

Use it when you need repeatable DexScreener data extraction for research, dashboards, lead lists, trading analysis, alerts, or AI workflows. You can run it manually, schedule it on [Apify schedules](https://docs.apify.com/platform/schedules), call it through the [Apify API](https://docs.apify.com/api/v2), or connect results to [Apify integrations](https://apify.com/integrations).

### What can DexScreener Crypto Scraper do?

- Extract token prices, liquidity, market cap, FDV, volume, pair age, transaction counts, websites, and socials.
- Search by blockchain such as `solana`, `ethereum`, `bsc`, `base`, or a chain/DEX segment such as `solana/pumpswap`.
- Apply filters for liquidity, market cap, FDV, pair age, 24h volume, 24h transactions, buys, sells, and 24h price change.
- Replay raw DexScreener URL query strings with `filterArgs` for advanced workflows.
- Export data as JSON, CSV, Excel, HTML, or XML from Apify dataset storage.
- Schedule recurring runs and pull results through API clients, webhooks, or integrations.

### What data can you extract from DexScreener?

| Field | Description |
|-------|-------------|
| `tokenName`, `tokenSymbol` | Token name and ticker |
| `chainId`, `dexId` | Blockchain and decentralized exchange identifiers |
| `address`, `lowerPoolAddress` | Token contract and pool/pair addresses |
| `priceUsd` | Current token price in USD |
| `priceChange5m`, `priceChange1h`, `priceChange6h`, `priceChange24h` | Price change percentages |
| `volumeUsd` | 24-hour trading volume in USD |
| `transactionCount`, `makerCount` | 24-hour transaction count and maker count when provided |
| `liquidityUsd`, `marketCapUsd`, `fdvUsd` | Liquidity, market cap, and fully diluted valuation |
| `age` | Pair age in hours |
| `pairDetailUrl`, `tokenImageUrl` | DexScreener pair URL and token image URL |
| `websites`, `socials` | Official links from DexScreener token metadata when available |

### How to scrape DexScreener with DexScreener Crypto Scraper

1. Open DexScreener Crypto Scraper on Apify and click **Try for free**.
2. Set `chainName`, for example `solana`, `ethereum`, `bsc`, or `solana/pumpswap`.
3. Pick `time`, `rankBy`, and `order`.
4. Add optional filters such as `minLiq`, `minMarketCap`, `min24HVol`, or `min24HChg`.
5. For advanced runs, visit [DexScreener](https://dexscreener.com/), apply filters in the UI, copy everything after `?`, and paste it into `filterArgs`.
6. Set `fromPage`, `toPage`, `limit`, and `limitPerPage`, then start the Actor.
7. Download the dataset or call it from your code.

### How much does it cost to scrape DexScreener?

DexScreener Crypto Scraper uses pay-per-event pricing. One event is one DexScreener token or pair record pushed to the dataset.

| Event | Price per event | Price per 1,000 |
|-------|-----------------|-----------------|
| `token-scraped` | $0.00149 | **$1.49** |
| `token-scraped` on gold tier | $0.00139 | **$1.39** |

Apify free trial credits can be used where applicable. For example, a 1,000-record run costs $1.49 before platform usage costs on free, bronze, and silver tiers.

### Input / Output

Common input:

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `chainName` | string | **Yes** | `solana` | Blockchain or chain/DEX segment |
| `time` | string | No | `24h` | Timeframe: `24h`, `6h`, `1h`, `5m` |
| `rankBy` | string | No | `trendingScoreH24` | Sort field |
| `order` | string | No | `desc` | Sort direction |
| `filterArgs` | array | No | `[]` | Raw DexScreener URL query strings |
| `fromPage`, `toPage` | integer | No | `1`, `1` | Page range; `toPage: -1` uses all available fetched records |
| `limit`, `limitPerPage` | integer | No | `10`, `10` | Result caps; `0` means no cap/default page size |
| `addTokenDetails` | boolean | No | `false` | Enrich each token through the official token endpoint |
| `addTopTraders` | boolean | No | `false` | Reserved until a stable public top-trader endpoint is verified |

Output example:

```json
{
  "tokenName": "Wrapped SOL",
  "tokenSymbol": "SOL",
  "chainId": "solana",
  "dexId": "orca",
  "address": "So11111111111111111111111111111111111111112",
  "lowerPoolAddress": "czfq3xzzdmsdgduyrnltrhgc47cxcztlg4crryfu44ze",
  "priceUsd": 81.23,
  "priceChange5m": -0.05,
  "priceChange1h": -0.06,
  "priceChange6h": 0.32,
  "priceChange24h": -0.8,
  "volumeUsd": 117914398.54,
  "transactionCount": 44653,
  "liquidityUsd": 25486870.57,
  "marketCapUsd": 51200000000,
  "fdvUsd": 51200000000,
  "age": 26300.5,
  "pairDetailUrl": "https://dexscreener.com/solana/czfq3xzzdmsdgduyrnltrhgc47cxcztlg4crryfu44ze",
  "tokenImageUrl": "https://cdn.dexscreener.com/cms/images/..."
}
```

Download results in JSON, HTML, CSV, or Excel, or retrieve them through the [Apify API](https://docs.apify.com/api/v2).

#### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/dexscreener-crypto-scraper").call(run_input={
    "chainName": "solana",
    "rankBy": "trendingScoreH24",
    "order": "desc",
    "limit": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tokenSymbol"], item.get("priceUsd"))
```

#### JavaScript API example

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/dexscreener-crypto-scraper').call({
  chainName: 'solana',
  rankBy: 'trendingScoreH24',
  order: 'desc',
  limit: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((item) => [item.tokenSymbol, item.priceUsd]));
```

### Is it legal to scrape DexScreener?

DexScreener Crypto Scraper extracts public token, pair, and market metadata from DexScreener API responses. You should use scraped data responsibly and comply with applicable laws, DexScreener terms, and privacy regulations. Public wallet or token-related data may still be regulated in some jurisdictions. Read Apify's overview: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

DexScreener is a trademark of its owner. This Actor is independent and is not affiliated with, endorsed by, or sponsored by DexScreener.

### Other DexScreener scrapers / Related Actors

| Actor | Use case |
|-------|----------|
| [GMGN CopyTrade Wallet Scraper](https://apify.com/parsebird/gmgn-copytrade-wallet-scraper) | Wallet PnL, win rates, balances, and trading stats |
| [Polymarket Market Scraper](https://apify.com/parsebird/polymarket-market-scraper) | Prediction-market prices and market metadata |
| [Polymarket Leaderboard Scraper](https://apify.com/parsebird/polymarket-scraper) | Trader leaderboard data |

### Pricing

| Event | Price per event | Price per 1,000 |
|-------|-----------------|-----------------|
| `token-scraped` | $0.00149 | **$1.49** |
| `token-scraped` on gold tier | $0.00139 | **$1.39** |

Each event is one token or pair record saved to the dataset.

### FAQ

**Can I use this as a DexScreener API alternative?**
Yes. It gives you Apify scheduling, dataset exports, API clients, webhooks, and integrations around verified DexScreener public API data.

**Does `filterArgs` override structured filters?**
Yes. When `filterArgs` contains one or more query strings, each entry runs as its own pass and overrides the structured sort and filter fields for that pass.

**Why are top traders skipped?**
Top trader data is only added when a stable public DexScreener endpoint is verified. This release avoids inventing wallet data or relying on an unverified private endpoint.

**Can I schedule recurring DexScreener scraping?**
Yes. Use Apify schedules to run hourly, daily, weekly, or at a custom interval.

**Can I connect results to Google Sheets, Make, or Zapier?**
Yes. Use Apify integrations, webhooks, or the API to send DexScreener data into spreadsheets, databases, dashboards, or automation tools.

**Where do I report problems or request a filter?**
Open an issue on the Actor page. Include your input JSON and the DexScreener URL you are trying to reproduce.

# Actor input Schema

## `chainName` (type: `string`):

Enter a DexScreener chain slug such as solana, ethereum, bsc, base, polygon, or chain/dex such as solana/pumpswap.

## `time` (type: `string`):

Timeframe used by sorting fields that have 5m, 1h, 6h, or 24h variants.

## `rankBy` (type: `string`):

Sort field. Trending-score fields are accepted for DexScreener URL compatibility; when the public API does not expose a score, the actor uses the closest available trading activity metric.

## `order` (type: `string`):

Sort order.

## `fromPage` (type: `integer`):

First page to include. Pages are applied after fetching and sorting public API results.

## `toPage` (type: `integer`):

Last page to include. Use -1 to include all available fetched results.

## `limit` (type: `integer`):

Maximum records to return. Use 0 for no total cap.

## `limitPerPage` (type: `integer`):

Records per page for local pagination. Use 0 for the default of 30.

## `minLiq` (type: `number`):

Minimum liquidity in USD.

## `maxLiq` (type: `number`):

Maximum liquidity in USD.

## `minMarketCap` (type: `number`):

Minimum market capitalization in USD.

## `maxMarketCap` (type: `number`):

Maximum market capitalization in USD.

## `minFdv` (type: `number`):

Minimum fully diluted valuation in USD.

## `maxFdv` (type: `number`):

Maximum fully diluted valuation in USD.

## `minAge` (type: `number`):

Minimum pair age in hours.

## `maxAge` (type: `number`):

Maximum pair age in hours.

## `min24HVol` (type: `number`):

Minimum 24-hour volume in USD.

## `max24HVol` (type: `number`):

Maximum 24-hour volume in USD.

## `min24HTxns` (type: `integer`):

Minimum 24-hour transaction count.

## `max24HTxns` (type: `integer`):

Maximum 24-hour transaction count.

## `min24HBuys` (type: `integer`):

Minimum 24-hour buy count.

## `min24HSells` (type: `integer`):

Minimum 24-hour sell count.

## `min24HChg` (type: `number`):

Minimum 24-hour price change percentage. Negative values are allowed.

## `max24HChg` (type: `number`):

Maximum 24-hour price change percentage. Negative values are allowed.

## `filterArgs` (type: `array`):

Paste raw DexScreener URL query strings such as ?rankBy=priceChangeH24\&order=desc\&minLiq=25000. Non-empty values override structured sort and filter fields.

## `addTokenDetails` (type: `boolean`):

Fetch the official token endpoint for each base token and merge verified fields such as FDV, websites, and socials when available.

## `addTopTraders` (type: `boolean`):

Reserved for verified top-trader endpoints. If enabled before a stable endpoint is available, the actor logs a warning and skips trader extraction.

## `topTradersTimeframe` (type: `string`):

Timeframe for top traders when a verified top-trader endpoint is available.

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

Proxy settings. Disabled by default because the verified public API is reachable directly.

## Actor input object example

```json
{
  "chainName": "solana",
  "time": "24h",
  "rankBy": "trendingScoreH24",
  "order": "desc",
  "fromPage": 1,
  "toPage": 1,
  "limit": 10,
  "limitPerPage": 10,
  "filterArgs": [],
  "addTokenDetails": false,
  "addTopTraders": false,
  "topTradersTimeframe": "7d",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "chainName": "solana",
    "time": "24h",
    "rankBy": "trendingScoreH24",
    "order": "desc",
    "fromPage": 1,
    "toPage": 1,
    "limit": 10,
    "limitPerPage": 10,
    "filterArgs": [],
    "addTokenDetails": false,
    "addTopTraders": false,
    "topTradersTimeframe": "7d",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/dexscreener-crypto-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 = {
    "chainName": "solana",
    "time": "24h",
    "rankBy": "trendingScoreH24",
    "order": "desc",
    "fromPage": 1,
    "toPage": 1,
    "limit": 10,
    "limitPerPage": 10,
    "filterArgs": [],
    "addTokenDetails": False,
    "addTopTraders": False,
    "topTradersTimeframe": "7d",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/dexscreener-crypto-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "chainName": "solana",
  "time": "24h",
  "rankBy": "trendingScoreH24",
  "order": "desc",
  "fromPage": 1,
  "toPage": 1,
  "limit": 10,
  "limitPerPage": 10,
  "filterArgs": [],
  "addTokenDetails": false,
  "addTopTraders": false,
  "topTradersTimeframe": "7d",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parsebird/dexscreener-crypto-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parsebird/dexscreener-crypto-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DexScreener Crypto Scraper | Token Data API",
        "description": "Extract DexScreener token data: prices, liquidity, market cap, volume, transactions, FDV, pair URLs, socials. Filter, schedule, use API, export JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "PRwHxFrw2v5Q38wuA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~dexscreener-crypto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-dexscreener-crypto-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parsebird~dexscreener-crypto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-dexscreener-crypto-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parsebird~dexscreener-crypto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-dexscreener-crypto-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "chainName"
                ],
                "properties": {
                    "chainName": {
                        "title": "Blockchain",
                        "type": "string",
                        "description": "Enter a DexScreener chain slug such as solana, ethereum, bsc, base, polygon, or chain/dex such as solana/pumpswap.",
                        "default": "solana"
                    },
                    "time": {
                        "title": "Timeframe",
                        "enum": [
                            "24h",
                            "6h",
                            "1h",
                            "5m"
                        ],
                        "type": "string",
                        "description": "Timeframe used by sorting fields that have 5m, 1h, 6h, or 24h variants.",
                        "default": "24h"
                    },
                    "rankBy": {
                        "title": "Rank By",
                        "enum": [
                            "trendingScoreH24",
                            "trendingScoreH6",
                            "trendingScoreH1",
                            "trendingScoreM5",
                            "volume",
                            "txns",
                            "buys",
                            "sells",
                            "priceChangeH24",
                            "priceChangeH6",
                            "priceChangeH1",
                            "priceChangeM5",
                            "liquidity",
                            "marketCap",
                            "fdv",
                            "pairAge",
                            "activeBoosts"
                        ],
                        "type": "string",
                        "description": "Sort field. Trending-score fields are accepted for DexScreener URL compatibility; when the public API does not expose a score, the actor uses the closest available trading activity metric.",
                        "default": "trendingScoreH24"
                    },
                    "order": {
                        "title": "Order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Sort order.",
                        "default": "desc"
                    },
                    "fromPage": {
                        "title": "From Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "First page to include. Pages are applied after fetching and sorting public API results.",
                        "default": 1
                    },
                    "toPage": {
                        "title": "To Page",
                        "minimum": -1,
                        "type": "integer",
                        "description": "Last page to include. Use -1 to include all available fetched results.",
                        "default": 1
                    },
                    "limit": {
                        "title": "Total Limit",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to return. Use 0 for no total cap.",
                        "default": 10
                    },
                    "limitPerPage": {
                        "title": "Limit Per Page",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Records per page for local pagination. Use 0 for the default of 30.",
                        "default": 10
                    },
                    "minLiq": {
                        "title": "Min Liquidity",
                        "type": "number",
                        "description": "Minimum liquidity in USD."
                    },
                    "maxLiq": {
                        "title": "Max Liquidity",
                        "type": "number",
                        "description": "Maximum liquidity in USD."
                    },
                    "minMarketCap": {
                        "title": "Min Market Cap",
                        "type": "number",
                        "description": "Minimum market capitalization in USD."
                    },
                    "maxMarketCap": {
                        "title": "Max Market Cap",
                        "type": "number",
                        "description": "Maximum market capitalization in USD."
                    },
                    "minFdv": {
                        "title": "Min FDV",
                        "type": "number",
                        "description": "Minimum fully diluted valuation in USD."
                    },
                    "maxFdv": {
                        "title": "Max FDV",
                        "type": "number",
                        "description": "Maximum fully diluted valuation in USD."
                    },
                    "minAge": {
                        "title": "Min Pair Age",
                        "type": "number",
                        "description": "Minimum pair age in hours."
                    },
                    "maxAge": {
                        "title": "Max Pair Age",
                        "type": "number",
                        "description": "Maximum pair age in hours."
                    },
                    "min24HVol": {
                        "title": "Min 24H Volume",
                        "type": "number",
                        "description": "Minimum 24-hour volume in USD."
                    },
                    "max24HVol": {
                        "title": "Max 24H Volume",
                        "type": "number",
                        "description": "Maximum 24-hour volume in USD."
                    },
                    "min24HTxns": {
                        "title": "Min 24H Txns",
                        "type": "integer",
                        "description": "Minimum 24-hour transaction count."
                    },
                    "max24HTxns": {
                        "title": "Max 24H Txns",
                        "type": "integer",
                        "description": "Maximum 24-hour transaction count."
                    },
                    "min24HBuys": {
                        "title": "Min 24H Buys",
                        "type": "integer",
                        "description": "Minimum 24-hour buy count."
                    },
                    "min24HSells": {
                        "title": "Min 24H Sells",
                        "type": "integer",
                        "description": "Minimum 24-hour sell count."
                    },
                    "min24HChg": {
                        "title": "Min 24H Change",
                        "type": "number",
                        "description": "Minimum 24-hour price change percentage. Negative values are allowed."
                    },
                    "max24HChg": {
                        "title": "Max 24H Change",
                        "type": "number",
                        "description": "Maximum 24-hour price change percentage. Negative values are allowed."
                    },
                    "filterArgs": {
                        "title": "Advanced Filter Args",
                        "type": "array",
                        "description": "Paste raw DexScreener URL query strings such as ?rankBy=priceChangeH24&order=desc&minLiq=25000. Non-empty values override structured sort and filter fields.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "addTokenDetails": {
                        "title": "Add Token Details",
                        "type": "boolean",
                        "description": "Fetch the official token endpoint for each base token and merge verified fields such as FDV, websites, and socials when available.",
                        "default": false
                    },
                    "addTopTraders": {
                        "title": "Add Top Traders",
                        "type": "boolean",
                        "description": "Reserved for verified top-trader endpoints. If enabled before a stable endpoint is available, the actor logs a warning and skips trader extraction.",
                        "default": false
                    },
                    "topTradersTimeframe": {
                        "title": "Top Traders Timeframe",
                        "enum": [
                            "24h",
                            "7d",
                            "30d"
                        ],
                        "type": "string",
                        "description": "Timeframe for top traders when a verified top-trader endpoint is available.",
                        "default": "7d"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Disabled by default because the verified public API is reachable directly."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
