DexScreener API Guide: Endpoints, Limits & Examples

The DexScreener API is free, public, and needs no API key. Point requests at https://api.dexscreener.com, stay under the documented rate limits, and you can pull live price, volume, and liquidity for almost any token trading on a DEX on any major chain. Here’s the practical map: the endpoints that matter, the fields worth reading, and two copy-paste examples.

Quick reference

Base URL	https://api.dexscreener.com
Auth	None — no key, no registration
Cost	Free
Format	JSON over HTTPS
Rate limits	~300 req/min (pairs/search), ~60 req/min (profiles/boosts)
Docs	docs.dexscreener.com

One mental model prevents most confusion: DexScreener indexes pairs, not tokens. A “pair” is a token’s pool on a specific DEX (say, TOKEN/WETH on a Base DEX). One token can have several pairs, and a token with no DEX pool — for example, a coin still on a launchpad bonding curve — doesn’t exist to the API at all.

The endpoints that matter

The three classic endpoints under /latest/dex/ cover most use cases:

Endpoint	What it returns
GET /latest/dex/search?q=	Pairs matching a ticker, name, or address
GET /latest/dex/pairs/{chainId}/{pairId}	One specific pair, fully detailed
GET /latest/dex/tokens/{tokenAddress}	All pairs for a token address

The newer versioned endpoints add token-level views and the boosts system:

Endpoint	What it returns
GET /token-pairs/v1/{chainId}/{tokenAddress}	The pools for a token on one chain
GET /token-profiles/latest/v1	Latest tokens with enhanced profiles
GET /token-boosts/latest/v1	Recently boosted tokens
GET /token-boosts/top/v1	Tokens with the most active boosts

chainId is a slug, not a number: base, solana, ethereum, and so on. For everyday “what’s this coin doing” queries, the token endpoint is the workhorse — you rarely need to know a pair address in advance, since the token endpoint hands you every pair it trades in.

Rate limits

Per the docs at docs.dexscreener.com: roughly 300 requests per minute for the pair, search, and token endpoints, and 60 requests per minute for the profile and boost endpoints. Two practical notes:

• These are unofficial-API numbers — check the docs before shipping anything that depends on them, because they can change without a deprecation cycle.
• Responses are cached on DexScreener’s side for a few seconds anyway, so polling a pair every second buys you nothing except a faster path to a 429. A poll every 5–10 seconds is as fresh as the data gets.

Response fields worth knowing

Each pair object carries more than you’ll usually need. The fields that do the work:

Field	What it is
priceUsd	Current price in USD (a string — parse it)
priceChange.h24	24-hour price change, percent (also m5, h1, h6)
volume.h24	24-hour volume in USD
liquidity.usd	Pool liquidity in USD
fdv	Fully diluted valuation
marketCap	Circulating market cap
pairCreatedAt	Pool creation timestamp (ms) — the token’s DEX age
info.socials	Website and social links, if the listing is claimed

fdv versus marketCap matters more than beginners expect — same token, very different numbers when supply isn’t fully circulating. And pairCreatedAt is quietly one of the most useful fields for filtering: it tells you exactly how new a pool is, which is most of what “early” means.

Copy-paste examples

Everything below works as-is — swap in a real token address.

A curl one-liner to see the raw shape of the data:

curl -s "https://api.dexscreener.com/latest/dex/tokens/TOKEN_ADDRESS"

The same pattern works for search — useful when you have a ticker but no address:

curl -s "https://api.dexscreener.com/latest/dex/search?q=WETH%20USDC"

Search returns pairs ranked by relevance, so expect impostors when querying popular tickers by name; anything serious should resolve the contract address once and query by address from then on.

A minimal JavaScript fetch that prints price, liquidity, and volume for a token’s most liquid pair:

const token = "TOKEN_ADDRESS"; // works across chains — no chainId needed
const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${token}`);
const { pairs } = await res.json();
if (!pairs?.length) throw new Error("No pairs — token may not have hit a DEX yet");

const top = pairs.sort((a, b) => (b.liquidity?.usd ?? 0) - (a.liquidity?.usd ?? 0))[0];
console.log(`${top.baseToken.symbol} on ${top.chainId} (${top.dexId})`);
console.log(`Price: $${top.priceUsd}`);
console.log(`Liquidity: $${Math.round(top.liquidity.usd).toLocaleString()}`);
console.log(`24h volume: $${Math.round(top.volume.h24).toLocaleString()}`);

Sorting by liquidity matters: a token often has one real pool and several dusty ones, and the thin pools quote misleading prices. Take the deepest pool as truth.

What people actually build with it

• Post-graduation tracking. If you’ve launched a coin on a launchpad like ape.store, it hits the API the moment it graduates and its DEX pool exists. A tiny script watching priceUsd and liquidity.usd is how creators keep honest, headless tabs on their token after launch — no tab-refreshing required.
• Alert scripts. Poll a pair, compare against thresholds, ping a Telegram or Discord webhook on breach. Price floors, liquidity drops, and volume spikes are each a dozen lines of code.
• Dashboards. Aggregate a portfolio’s pairs into one view, refreshed on a polite interval — the search and token endpoints are enough for a personal terminal.

Caveats before you build

• It’s unofficial and changeable. No SLA, no versioning promises on the /latest/ endpoints, no deprecation calendar. Wrap calls in error handling and expect the occasional surprise.
• Data is cached. A few seconds of staleness is normal. For trade execution timing that matters; for tracking and alerts it doesn’t.
• There’s no public websocket. Streaming isn’t offered — polling is the model, so poll politely and batch what you can.
• Bonding-curve coins are invisible until migration. The API sees DEX pairs only. A coin mid-curve on a launchpad has no pair, so “my token isn’t in the API” almost always means “my token hasn’t graduated yet” — the bonding-curve explainer covers why the pool only exists after migration.
• The API gives numbers, not judgment. Reading a chart still takes a human. The companion piece on reading DexScreener itself covers what the numbers mean when you’re deciding whether to touch a coin at all.

The bottom line

For a free, keyless API, DexScreener’s is remarkably usable: one base URL, predictable JSON, and enough endpoints to cover tracking, alerts, and dashboards. Treat the rate limits with respect, sort pairs by liquidity, remember that curve-stage coins don’t exist yet as far as the API is concerned — and you can go from zero to a working price tracker in the time it took to read this page.