# DexScreener Scraper — DEX Pairs, Prices, Boosts & Trending (`brilliant_gum/dexscreener-scraper`) Actor

Scrape DexScreener DEX token & pair market data across every chain — prices, liquidity, volume, transactions, FDV, market cap, boosts, token profiles and new pairs — with derived trading-signal analytics on every record. 6 modes, no login, no API key.

- **URL**: https://apify.com/brilliant\_gum/dexscreener-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.003 / result record

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Scraper — token pairs, prices, liquidity, volume, boosts & trading analytics (no key)

Pull **DEX token & pair market data across every chain** DexScreener covers — prices, liquidity, volume,
transactions, price change, FDV, market cap, boosts and freshly-profiled tokens — and get **derived
trading signals** computed on top of every record. Built for crypto **traders, analysts, and model/bot
builders** who need clean, structured DEX data without wiring up an API key, a login, or a headless
browser.

Every mode runs on DexScreener's **official, free, keyless public API** (`api.dexscreener.com`).
**No API key. No cookies. No wallet.**

![DexScreener Scraper](https://api.apify.com/v2/key-value-stores/IuFu0Cw6PpOkNkDV7/records/dexscreener-scraper-banner.png)

> **Enjoying this Actor?** If it's useful, please leave a ⭐️ rating and a short review — it genuinely helps. **Something not working right?** Open an issue on the Actor's **Issues** tab — I actively maintain this Actor and respond fast to fix problems and help you get things working.

***

### Key features

**6 scraping modes**

| Mode | What it returns |
|------|-----------------|
| `search` | Free-text search by token symbol / name / contract / pair address. Multiple `queries`, merged & de-duplicated. |
| `pair-details` | Exact pair lookup by `chainId` + `pairAddress` (or bare `pairAddresses` + `chain`). Optional paid-order history. |
| `token-pairs` | Every liquidity pool/pair a token contract trades in (deepest-liquidity pool flagged). |
| `trending-boosts` | Boosted / promoted (paid-trending) tokens — `top` (by total boost) or `latest`, enriched with live pair data. |
| `latest-token-profiles` | Freshly profiled tokens (description / icon / website / socials), enriched with live pair data. |
| `new-pairs-by-chain` | Freshest **profiled/boosted** tokens on the chosen chain(s), newest first, with a `maxPairAgeHours` cutoff. (DexScreener exposes no public "all-new-pairs" endpoint, so newly profiled/boosted tokens are used as the freshness proxy.) |

**Full market fields on every record** — `priceUsd`, `priceNative`, `liquidity` (usd/base/quote),
`volume` (m5/h1/h6/h24), `txns` (buys/sells per timeframe), `fdv`, `marketCap`, `priceChange`
(m5/h1/h6/h24), token metadata, image/website/socials.

**Derived trading analytics competitors don't ship** — every record includes an `analytics` block
computed from the market data:

- `buyPressure` — buys / (buys + sells), 0..1, per timeframe
- `buySellRatio` — buys / sells, per timeframe
- `volumeToLiquidity` — turnover (volume ÷ liquidity), a churn/risk signal
- `volumePerTxn` — average trade size (USD)
- `priceChangeMomentum` — h1 − h6 (short vs mid trend)
- `priceChangeAcceleration` — (h1 − h6) − (h6 − h24)
- `volumeTrend` — recent pace vs realized 24h volume
- `liquidityToMarketCap`, `fdvToMarketCap` — depth and dilution ratios
- `trendingScore` — a transparent composite heat score from public fields (see FAQ)

**Plus** paid-order/boost history (`includeOrders`), token profiles, and full **client-side filters &
ranking** (`rankBy` / `order`, min/max liquidity / volume / market cap / FDV / price-change / txns /
pair age, `dexIds`, `labels`, `quoteSymbols`, `requireSocials`, `requireBoosted`). Nested or `flat`
(spreadsheet/CSV-friendly) output.

***

### Input

Set `mode` and the fields that mode needs. Convenience: `query` merges into `queries`, `chain` merges
into `chains`. All numeric filters default to absent (no filtering).

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | enum | `search` | `search` / `pair-details` / `token-pairs` / `trending-boosts` / `latest-token-profiles` / `new-pairs-by-chain` |
| `query` | string | `SOL` | search: single term (symbol / name / address). Merged into `queries`. |
| `queries` | array | `[]` | search: multiple terms; results merged & de-duplicated. |
| `chain` | string | — | Single chain id (token-pairs / new-pairs / pair-details). Merged into `chains`. |
| `chains` | array | `[]` | One or more chain ids (token-pairs source chains, new-pairs chains, search result filter). |
| `tokenAddresses` | array | `[]` | token-pairs: token contract/mint address(es), ≤30 per batch. |
| `pairs` | array | `[]` | pair-details: `"chainId/pairAddress"` entries. |
| `pairAddresses` | array | `[]` | pair-details: bare pair addresses (paired with `chain`). |
| `boostType` | enum | `top` | trending-boosts: `top` (by total boost) or `latest`. |
| `rankBy` | enum | `volumeH24` | Sort key — see Ranking below. |
| `order` | enum | `desc` | `desc` (highest first) or `asc`. |
| `timeframe` | enum | `h24` | Timeframe for the volume/txns/price-change filters: `m5` / `h1` / `h6` / `h24`. |
| `minLiquidityUsd` / `maxLiquidityUsd` | number | — | Liquidity (USD) bounds. |
| `minVolumeUsd` / `maxVolumeUsd` | number | — | Volume (USD, selected timeframe) bounds. |
| `minMarketCap` / `maxMarketCap` | number | — | Market cap (USD) bounds. |
| `minFdv` / `maxFdv` | number | — | FDV (USD) bounds. |
| `minPriceChange` / `maxPriceChange` | number | — | Price-change % (timeframe) bounds (use negatives for drops). |
| `minTxns` | integer | — | Min total txns (buys + sells) in timeframe. |
| `minBuys` / `minSells` | integer | — | Min buys / sells in timeframe. |
| `minPairAgeHours` / `maxPairAgeHours` | number | — | Pair age (hours) bounds. |
| `dexIds` | array | `[]` | Keep only these DEXes (e.g. `raydium`, `orca`, `uniswap`, `pancakeswap`, `meteora`). |
| `labels` | array | `[]` | Keep only these pair labels (e.g. `v2`, `v3`, `v4`, `CLMM`, `DLMM`). |
| `quoteSymbols` | array | `[]` | Keep only pairs quoted in these tokens (e.g. `SOL`, `USDC`, `WETH`). |
| `requireSocials` | boolean | `false` | Keep only tokens with website/socials/info. |
| `requireBoosted` | boolean | `false` | Keep only currently boosted tokens. |
| `includeOrders` | boolean | `false` | Attach paid-order/boost history (`/orders/v1`). |
| `includeAnalytics` | boolean | `true` | Attach the derived analytics block. |
| `flat` | boolean | `false` | Emit flat one-row-per-pair records (analytics hoisted to top level). |
| `maxItems` | integer | `100` | Max output records for the run. |
| `maxItemsPerQuery` | integer | `0` | Cap results per query / chain / source (0 = no cap). |
| `proxyConfiguration` | object | `{ useApifyProxy: false }` | Optional. Public API works direct; proxy available for scale/geo. |

**Ranking (`rankBy`):** `volumeH24, volumeH6, volumeH1, volumeM5, liquidityUsd, marketCap, fdv,
priceUsd, txnsH24, txnsH6, txnsH1, txnsM5, buysH24, sellsH24, priceChangeH24, priceChangeH6,
priceChangeH1, priceChangeM5, pairAgeHours, boostAmount, buyPressureH24, volumeToLiquidity,
trendingScore`. Ranking is applied **client-side** over the fetched records, then `maxItems` is applied.

#### Example inputs

**Search across chains for a token, sorted by 24h volume**

```json
{
  "mode": "search",
  "queries": ["SOL", "PEPE"],
  "rankBy": "volumeH24",
  "minLiquidityUsd": 25000,
  "maxItems": 50
}
```

**All pools of a token contract**

```json
{
  "mode": "token-pairs",
  "chain": "solana",
  "tokenAddresses": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"],
  "rankBy": "liquidityUsd"
}
```

**Exact pair details with paid-order history**

```json
{
  "mode": "pair-details",
  "pairs": ["solana/5miPLrTZrMWqN5ubb22GPCjjyZgbQMB5jei7zNwDweZ8"],
  "includeOrders": true
}
```

**Boosted (paid-trending) tokens, enriched with live pair data**

```json
{
  "mode": "trending-boosts",
  "boostType": "top",
  "minLiquidityUsd": 10000,
  "maxItems": 50
}
```

***

### Output

One dataset record per pair (or per token, for freshly profiled/boosted tokens with no live pool yet).
Every mode emits the same **core pair fields + analytics**. Set `flat: true` for a denormalized
one-row-per-pair shape.

#### Core pair record — real, trimmed

```json
{
  "recordType": "pair",
  "mode": "search",
  "chainId": "solana",
  "dexId": "pumpswap",
  "dexLabels": [],
  "pairAddress": "2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd",
  "url": "https://dexscreener.com/solana/2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd",
  "baseToken":  { "address": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn", "name": "Pump", "symbol": "PUMP" },
  "quoteToken": { "address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "name": "USD Coin", "symbol": "USDC" },
  "priceUsd": 0.003904,
  "priceNative": 0.003904,
  "priceChange": { "m5": 0.75, "h1": 0.72, "h6": -2.02, "h24": -7.79 },
  "volume":      { "m5": 39532.33, "h1": 418917.44, "h6": 1082318.21, "h24": 2811206.31 },
  "txns": {
    "m5":  { "buys": 82,   "sells": 3    },
    "h1":  { "buys": 550,  "sells": 118  },
    "h6":  { "buys": 1971, "sells": 645  },
    "h24": { "buys": 7172, "sells": 1901 }
  },
  "liquidity": { "usd": 21177427.97, "base": 2715067096, "quote": 10575503 },
  "fdv": 3262447185,
  "marketCap": 3262447185,
  "pairCreatedAt": "2025-07-14T16:55:49.000Z",
  "pairAgeHours": 10039.836,
  "info": {
    "imageUrl": null, "header": null, "openGraph": null,
    "websites": [ { "label": null, "url": "https://pump.fun" } ],
    "socials":  [ { "type": "twitter", "url": "https://x.com/pumpfun" } ]
  },
  "boosts": null,
  "profile": null,
  "orders": null,
  "analytics": {
    "totalTxns":         { "m5": 85, "h1": 668, "h6": 2616, "h24": 9073 },
    "buySellRatio":      { "m5": 27.3333, "h1": 4.661, "h6": 3.0558, "h24": 3.7728 },
    "buyPressure":       { "m5": 0.9647, "h1": 0.8234, "h6": 0.7534, "h24": 0.7905 },
    "volumePerTxn":      { "m5": 465.0862, "h1": 627.1219, "h6": 413.7302, "h24": 309.8431 },
    "volumeToLiquidity": { "m5": 0.0019, "h1": 0.0198, "h6": 0.0511, "h24": 0.1327 },
    "liquidityToMarketCap": 0.006491,
    "fdvToMarketCap": 1,
    "priceChangeMomentum": 2.74,
    "priceChangeAcceleration": -3.03,
    "volumeTrend": 3.5764,
    "trendingScore": 2.7754,
    "boostAmount": null
  },
  "scrapedAt": "2026-09-06T00:45:59.283Z"
}
```

The `boosts`, `profile` and `orders` blocks populate when relevant (boosted tokens, profile modes,
`includeOrders`). Freshly profiled/boosted tokens with no live pool yet come back as a lighter
`recordType: "token"` record (address + profile/boost + a `note`, market fields `null`).

#### Field reference

- **Top level:** `recordType` (`pair` | `token`), `mode`, `chainId`, `dexId`, `dexLabels[]`,
  `pairAddress`, `url`, `baseToken{address,name,symbol}`, `quoteToken{…}`, `priceUsd`, `priceNative`,
  `priceChange{m5,h1,h6,h24}`, `volume{m5,h1,h6,h24}`, `txns{m5,h1,h6,h24:{buys,sells}}`,
  `liquidity{usd,base,quote}`, `fdv`, `marketCap`, `pairCreatedAt`, `pairAgeHours`,
  `info{imageUrl,header,openGraph,websites[],socials[]}`, `boosts{active,total}`,
  `profile{description,icon,header,links[],cto}`, `orders[{type,status,paymentTimestamp}]`,
  `analytics{…}`, `scrapedAt`.
- **`analytics`:** `totalTxns`, `buySellRatio`, `buyPressure`, `volumePerTxn`, `volumeToLiquidity`
  (each per timeframe), `liquidityToMarketCap`, `fdvToMarketCap`, `priceChangeMomentum`,
  `priceChangeAcceleration`, `volumeTrend`, `trendingScore`, `boostAmount`.
- **`token-pairs` mode only:** the deepest-liquidity pool per token contract is flagged with
  `isDeepestPool: true`.

Nulls are preserved (never coerced to `0`) so absent data stays honest.

***

### Pricing

**Pay-per-result.** You are charged per record (a `pair` or `token` row) pushed to the dataset — no
charge for empty runs. The exact per-record price is shown on the Actor's Store page. Because filtering
and ranking happen before records are emitted, use `maxItems`, the min/max filters and `chains` to pay
only for the data you want. There is no separate cost for the DexScreener data itself — the actor uses
free, keyless endpoints (you still pay your own Apify platform usage).

***

### Use cases

- **Trending / new-token discovery** — `trending-boosts` (paid-trending tokens), `latest-token-profiles`
  and `new-pairs-by-chain` to surface what's being promoted and what just launched.
- **Liquidity & volume scanning** — filter by `minLiquidityUsd`, `minVolumeUsd`, `volumeToLiquidity`,
  `dexIds` and `quoteSymbols` to find tradable, non-churny pools.
- **Signal feeds for bots & models** — schedule runs and consume `buyPressure`, `buySellRatio`,
  `priceChangeMomentum` / `priceChangeAcceleration`, `volumeTrend` and `trendingScore` as features.
- **Token due diligence** — pull `pair-details` / `token-pairs` for a contract: liquidity depth,
  FDV/MC dilution (`fdvToMarketCap`), socials, and paid-order/boost history.

***

### Honest limitations

We would rather under-promise:

- **Built on the official public API.** Every mode uses DexScreener's **official, documented, free
  public API** (`api.dexscreener.com`, published rate limits, no key). The actor respects those rate
  limits (300 req/min for search/pairs/tokens, 60 req/min for boosts/profiles/orders), so very large
  multi-chain pulls take proportionally longer.
- **`search` returns up to ~30 pairs per query.** That is DexScreener's own search-endpoint cap. Use
  several `queries`, or `token-pairs` for a specific contract, to go wider.
- **`new-pairs-by-chain` is a freshness *proxy*.** DexScreener has no public "all-new-pairs" endpoint,
  so this mode surfaces newly **profiled/boosted** tokens on the chain (newest first), which is the
  closest keyless signal for fresh launches — not an exhaustive list of every new pool. Narrow it with
  `maxPairAgeHours`.
- **Token-only records.** A freshly profiled/boosted token with no live tradable pool yet returns a
  lighter `recordType: "token"` record (market fields `null`) rather than being dropped.
- **Not affiliated with DexScreener.** On-chain market data (prices, liquidity, volume) is factual.
  This actor is for informational/analytical use; follow DexScreener's ToS and your local law. Crypto
  is volatile — nothing here is financial advice.

***

### FAQ

**Do I need an API key, login, or wallet?**
No. Every mode works keyless and login-free. `proxyConfiguration` is optional (the public API answers
directly); enable a proxy only for scale or geo needs.

**What chains are supported?**
Any chain id DexScreener returns is accepted (free-text pass-through). Common ones include `solana`,
`ethereum`, `base`, `bsc`, `arbitrum`, `polygon`, `avalanche`, `optimism`, `sui`, `ton`, `tron`,
`hyperevm`, `linea`, `blast`, `sei`, `unichain`, `berachain`, and more.

**What is `analytics.trendingScore`?**
A **transparent composite heat score** computed from public fields (roughly
`log10(1+volume24) × turnover × buy-pressure × recency`). It is a convenience ranking heuristic to
sort by momentum — clearly our own derived metric, not any exchange's internal score. Turn the whole
block off with `includeAnalytics: false`.

**Nested vs flat output?**
Default output is nested (analytics grouped under `analytics`). Set `flat: true` for a denormalized
one-row-per-pair shape (analytics and key numerics hoisted to the top level) — ideal for CSV/Excel.

**How do I control cost / result count?**
Use `maxItems` (whole-run cap), `maxItemsPerQuery` (per query/chain/source cap), and the min/max
filters so only the records you want are emitted and charged.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. search = free-text token/pair search; pair-details = exact pair by chain+address; token-pairs = all pools of a token address; trending-boosts = boosted/promoted (paid-trending) tokens; latest-token-profiles = newest profiled tokens; new-pairs-by-chain = freshest profiled/boosted tokens on chosen chains.

## `query` (type: `string`):

search mode: a single search term — token symbol, name, contract address or pair address (e.g. SOL, PEPE, or a mint address). Merged into `queries`.

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

search mode: one or more search terms. Results from all queries are merged and de-duplicated. If both this and `query` are empty, defaults to "SOL".

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

Single chain id (e.g. solana, ethereum, base, bsc). Used by token-pairs (source chain), new-pairs-by-chain, and pair-details (with bare pair addresses). Merged into `chains`.

## `chains` (type: `array`):

One or more chain ids. For new-pairs-by-chain the pairs are limited to these chains; for token-pairs these are the source chains to look up token pools on; for search these filter results by chain.

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

token-pairs mode: one or more token contract/mint addresses. Returns every liquidity pool/pair the token trades in. Up to 30 per batch.

## `pairs` (type: `array`):

pair-details mode: pair identifiers as "chainId/pairAddress" (or "chainId:pairAddress"), e.g. solana/Czfq3xZZDmsdGdUyrNLtRhGc47cXcZtLG4crryfu44zE.

## `pairAddresses` (type: `array`):

pair-details mode: bare pair addresses, resolved against `chain`/`chains`. Use this when all pairs share one chain.

## `boostType` (type: `string`):

trending-boosts mode: `top` = tokens with the highest total boost (strongest trending signal); `latest` = most recently boosted tokens.

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

Sort key. Applied client-side over the fetched records (then maxItems is applied). `trendingScore` is a transparent composite heat score from public fields (volume x turnover x buy-pressure x recency) — our own derived metric, not any exchange's internal score.

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

Sort direction for `rankBy`. desc = highest first (default), asc = lowest first.

## `timeframe` (type: `string`):

Primary timeframe used by the volume/txns/price-change filters and pressure summaries: 5 minutes, 1 hour, 6 hours or 24 hours.

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

Keep only pairs whose pool liquidity in USD is at least this value.

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

Keep only pairs whose pool liquidity in USD is at most this value.

## `minVolumeUsd` (type: `number`):

Keep only pairs whose trading volume (in the selected `timeframe`) is at least this value in USD.

## `maxVolumeUsd` (type: `number`):

Keep only pairs whose trading volume (in the selected `timeframe`) is at most this value in USD.

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

Keep only pairs whose token market cap is at least this value in USD.

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

Keep only pairs whose token market cap is at most this value in USD.

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

Keep only pairs whose fully-diluted valuation is at least this value in USD.

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

Keep only pairs whose fully-diluted valuation is at most this value in USD.

## `minPriceChange` (type: `number`):

Keep only pairs whose price change percentage in the selected `timeframe` is at least this value (use negative numbers for drops).

## `maxPriceChange` (type: `number`):

Keep only pairs whose price change percentage in the selected `timeframe` is at most this value.

## `minTxns` (type: `integer`):

Keep only pairs with at least this many total transactions (buys + sells) in the selected `timeframe`.

## `minBuys` (type: `integer`):

Keep only pairs with at least this many buy transactions in the selected `timeframe`.

## `minSells` (type: `integer`):

Keep only pairs with at least this many sell transactions in the selected `timeframe`.

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

Keep only pairs at least this many hours old (based on pair creation time).

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

Keep only pairs at most this many hours old — useful in new-pairs-by-chain to surface only very fresh launches.

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

Keep only pairs on these DEXes (e.g. raydium, orca, uniswap, pancakeswap, meteora). Empty = all DEXes.

## `labels` (type: `array`):

Keep only pairs carrying these labels (e.g. v2, v3, v4, CLMM, DLMM). Empty = all.

## `quoteSymbols` (type: `array`):

Keep only pairs quoted in these tokens (e.g. SOL, USDC, WETH, USDT). Empty = all quote tokens.

## `requireSocials` (type: `boolean`):

Keep only pairs whose token has a website or social links / info block attached.

## `requireBoosted` (type: `boolean`):

Keep only tokens that currently have an active boost.

## `includeOrders` (type: `boolean`):

pair-details / token-pairs / trending-boosts / profiles: attach the token's paid-order history (tokenProfile / tokenAd / boost purchases and their status) from the orders endpoint. Adds one request per token (60 req/min endpoint).

## `includeAnalytics` (type: `boolean`):

Attach the derived trading-signal analytics block (buy/sell pressure, turnover, momentum/acceleration, FDV/MC ratios, volume-per-txn, trending score) to every record.

## `flat` (type: `boolean`):

Emit flat, denormalized one-row-per-pair records (analytics and key numerics hoisted to the top level) instead of the nested structure — spreadsheet/CSV friendly.

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

Maximum number of output records to push for the whole run.

## `maxItemsPerQuery` (type: `integer`):

Cap results taken from each individual search query / chain / boost list before merging (0 = no per-source cap).

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

Optional. The DexScreener public API answers directly without a proxy; enable an Apify proxy only for scale or geo needs. When set, requests route through the chosen proxy.

## Actor input object example

```json
{
  "mode": "search",
  "query": "SOL",
  "queries": [],
  "chains": [],
  "tokenAddresses": [],
  "pairs": [],
  "pairAddresses": [],
  "boostType": "top",
  "rankBy": "volumeH24",
  "order": "desc",
  "timeframe": "h24",
  "dexIds": [],
  "labels": [],
  "quoteSymbols": [],
  "requireSocials": false,
  "requireBoosted": false,
  "includeOrders": false,
  "includeAnalytics": true,
  "flat": false,
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All pair and token records produced by the run.

# 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 = {
    "mode": "search",
    "query": "SOL",
    "chains": [],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/dexscreener-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "query": "SOL",
    "chains": [],
    "maxItems": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "query": "SOL",
  "chains": [],
  "maxItems": 100
}' |
apify call brilliant_gum/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mYRVtLAzyVEBB6KM6/builds/qURLEuE57KXnpIDEh/openapi.json