DexScreener API: Endpoints, Rate Limits & Alternatives (2026)

DexScreener API is the programmatic layer behind one of crypto's most-used DEX charting platforms — a set of REST and WebSocket endpoints that let developers pull token profiles, pair data, trending lists, and new-pool feeds without scraping the website. On Solana specifically, builders use the DexScreener API to monitor fresh Raydium, Orca, Meteora, and pump.fun migration pools in near real time. What most developers never learn is where the API stops being useful: it is a read-only discovery layer with strict rate limits, no execution hooks, and no wallet-copy infrastructure — and the gap between detecting a new pair via API and mirroring the wallet that bought it is where automated trading systems either win or bleed latency in 2026.

Most DexScreener API coverage online is the official docs page, a Python wrapper README, or a Reddit thread asking for alternatives when rate limits block a dashboard. Few articles answer the questions active Solana builders and traders actually ask: Is the DexScreener API free? What does each endpoint return? How do you poll new Solana pairs without getting throttled? Which endpoints matter for memecoin alerts? And what do you use when the API surfaces a wallet worth copying but cannot fire the trade? This guide maps every major endpoint, documents real rate-limit behavior, compares alternatives, and shows where the API fits in the research-to-execution stack alongside our DexScreener Solana UI guide and wallet tracker comparison.

The DexScreener API is a public HTTP and WebSocket interface to DexScreener's indexed DEX data across 80+ blockchains. Unlike the retail website — which renders charts, trending feeds, and pair pages for human traders — the API returns structured JSON for programmatic consumption: token metadata, latest pair snapshots, boosted-token lists, community takeovers, and real-time streaming updates over WebSockets.

Three architectural layers define how developers use the DexScreener API in 2026:

• REST endpoints. Stateless GET requests to api.dexscreener.com return token profiles, pair search results, and curated lists like latest boosted tokens. Each endpoint has its own rate limit — typically 60 requests per minute for high-traffic routes. REST is the default choice for cron-based alert bots and dashboard backends.
• WebSocket streams. The WebSocket API pushes real-time updates for token profiles, boosts, and community takeovers without polling. Useful when you need sub-minute freshness on promoted tokens — but it does not stream every new Solana pool the moment it lands on-chain.
• Pair search and lookup. Query by token contract address or pair address to retrieve price, liquidity, volume, FDV, and transaction counts aggregated from on-chain swap events. This is the endpoint most Solana alert bots call after detecting a new mint elsewhere.

The DexScreener API is not a trading API. It does not submit swaps, manage wallets, or mirror another trader's positions. It is a read-only data layer that serious Solana traders pair with execution infrastructure — manual terminals, Telegram bots, Jupiter routing, or a purpose-built Solana copy trading bot when speed matters more than chart UX.

Direct answer: the DexScreener API is free, legit, and genuinely useful for token discovery and pair metadata — but rate-limited, read-only, and insufficient as a standalone trading stack for Solana memecoin hunters who need sub-second execution. No API key is required for standard REST endpoints. Paid promoted listings exist on the retail side but do not unlock higher API tiers for most developers. The API shines when you need structured pair data for dashboards and alert bots — not when you need to copy a wallet before a bonding curve completes.

Category	Verdict	Notes
Price	Free	No API key for standard REST — rate limits apply
Token profiles endpoint	Very good	Latest profiles at /token-profiles/latest/v1
Pair search by address	Excellent	Lookup any Solana mint or pair — core alert-bot primitive
New pairs streaming	Moderate	No dedicated firehose — poll or combine with on-chain listeners
Rate limits	Restrictive	~60 req/min on hot endpoints — plan caching and backoff
Automated copy trading	Not offered	Pair with copy trade on Solana infrastructure

Yes — the DexScreener API is free for standard REST and WebSocket access as of 2026. DexScreener does not publish a paid API tier with higher rate limits on its public documentation. Developers call endpoints directly without registering an API key for the core routes documented at docs.dexscreener.com.

What "free" does and does not include:

• Included at no cost. Token profile lookups, pair search by contract address, latest boosted tokens, community takeover lists, and WebSocket streams for supported event types. These cover most alert-bot and dashboard use cases.
• Not included. Promoted token listings on the retail website (a marketing product, not an API upgrade). Historical OHLC candle exports beyond what pair endpoints return. Guaranteed sub-second indexing on brand-new Solana pools — the API reflects DexScreener's indexer speed, which lags raw on-chain events by seconds to minutes depending on pool type.
• Hidden cost: rate limits. Free does not mean unlimited. Hitting 60 requests per minute on profile endpoints triggers HTTP 429 responses. Production systems need exponential backoff, response caching, and deduplication — otherwise your alert bot goes silent during the exact windows when new pairs matter most.

Compare this to Birdeye, which gates premium wallet analytics and security panels behind paid tiers, or GeckoTerminal, which offers a separate CoinGecko API product with its own pricing. DexScreener's API is the most accessible free option for basic pair metadata — which is why it dominates GitHub wrapper repos and indie trading dashboards.

Direct answer: the endpoints that matter for Solana builders cluster around token profiles, pair lookup, boosted tokens, and search. DexScreener documents these at docs.dexscreener.com/api/reference. Below is a practical map — not a verbatim copy of the docs, but a trader-oriented guide to which routes solve which problems.

Token profiles: latest submissions {#token-profiles-endpoint}

GET https://api.dexscreener.com/token-profiles/latest/v1 returns the most recently submitted token profiles — projects that pushed metadata (logo, description, social links) through DexScreener's listing flow. Rate limit: approximately 60 requests per minute.

Use case: catch tokens that invested in DexScreener visibility before they trend organically. Alert bots poll this endpoint every 30–60 seconds, diff against a local cache, and fire Telegram or Discord notifications on new entries. Limitation: not every Solana memecoin submits a profile — most pump.fun launches never appear here until they migrate and a dev pays for promotion.

Pair lookup by token or pair address {#pair-lookup-endpoint}

GET https://api.dexscreener.com/latest/dex/tokens/{tokenAddress} and GET https://api.dexscreener.com/latest/dex/pairs/{chainId}/{pairAddress} are the workhorse endpoints. Pass a Solana mint address and receive all indexed pairs, price, liquidity, volume (5m / 1h / 6h / 24h), FDV, price change percentages, and the DEX identifier (raydium, orca, meteora, pumpswap).

Use case: after your on-chain listener detects a new Raydium pool, call the token endpoint to enrich it with DexScreener's aggregated metrics before deciding whether to trade. This is the highest-value endpoint for Solana alert pipelines because it works with any contract address DexScreener has indexed — no profile submission required.

Latest boosted tokens {#boosted-tokens-endpoint}

GET https://api.dexscreener.com/token-boosts/latest/v1 returns tokens with active DexScreener boost campaigns. Boosted tokens get homepage and trending visibility on the retail product — the API exposes which tokens paid for that placement.

Use case: filter out or flag promoted tokens in your scanner. Many profitable Solana traders treat boosts as a negative signal — paid visibility often precedes a dev dump. Your bot can auto-skip boosted entries or route them to a separate high-skepticism watchlist.

Community takeovers {#community-takeover-endpoint}

GET https://api.dexscreener.com/community-takeovers/latest/v1 lists tokens where the DexScreener community claimed the profile after the original deployer abandoned it. Relevant for memecoin culture plays where community revival drives secondary pumps.

Search endpoint {#search-endpoint}

GET https://api.dexscreener.com/latest/dex/search?q={query} performs a text search across indexed pairs. Less useful for automated Solana pipelines than address-based lookup — but handy for CLI tools and manual research scripts.

WebSocket streams {#websocket-endpoint}

The WebSocket API at docs.dexscreener.com/api/websockets streams real-time updates for token profiles, boosts, and community takeovers. Connection-based rather than poll-based — lower latency for profile and boost events, but it does not replace on-chain listeners for raw new-pool detection on Solana.

This is the question behind half the search volume on "dexscreener api new pairs solana" — and the honest answer is nuanced. DexScreener does not expose a dedicated "new pairs" REST endpoint that streams every fresh Solana pool the moment it lands on-chain. The retail website's new-pairs feed is a UI construct built on DexScreener's indexer, not a single API route you can poll.

How Solana developers actually detect new pairs with DexScreener API data:

• On-chain listener + DexScreener enrichment. Run a Solana RPC websocket subscription to Raydium, Orca, or pump.fun program logs. When a new pool event fires, call /latest/dex/tokens/{mint} to pull DexScreener's price, liquidity, and volume snapshot. This is the standard architecture in open-source GitHub repos like hedgey-finance/dexscreener-api wrappers.
• Token profiles polling. Poll /token-profiles/latest/v1 every 60 seconds and filter for Solana chainId entries. Catches tokens that submitted profiles — misses anonymous pump.fun launches that never file paperwork.
• Pair address batching. If you already have a list of candidate mints from another source (Solscan token listings, Helius webhooks, or a smart money wallet feed), batch-lookup via the tokens endpoint to rank by liquidity and volume before alerting.
• Retail UI for discovery, API for metadata. Many profitable traders use the DexScreener Solana new-pairs tab for human scanning and reserve the API for enriching alerts their on-chain stack already triggered. Trying to replace the entire discovery loop with API polling alone costs more in missed launches than it saves in infrastructure.

Latency reality on Solana: DexScreener indexes most Raydium and PumpSwap pools within one to five minutes of creation. Pump.fun bonding-curve tokens may not appear until migration. If your strategy requires sub-30-second entry on fresh mints, the API is a confirmation layer — not the detection layer. Pair on-chain listeners or specialized terminals from our Solana trading platform comparison for the first signal.

DexScreener publishes per-endpoint rate limits in its official documentation. The most commonly hit constraint: 60 requests per minute on token profile and boosted-token endpoints. Pair lookup endpoints tolerate higher burst traffic but still throttle aggressive polling.

Production patterns that keep your Solana alert bot alive:

• Cache responses locally. Store pair snapshots in Redis or SQLite with a 30–60 second TTL. Serve your dashboard from cache; refresh from DexScreener only when cache expires or a new on-chain event triggers a lookup.
• Deduplicate mint addresses. The same pump.fun token generates dozens of log events. Deduplicate by mint before calling the API — one lookup per unique token, not one per transaction.
• Exponential backoff on 429. When rate-limited, back off 2s → 4s → 8s rather than hammering the endpoint. Sustained 429s can extend cooldown windows.
• Batch by priority. Not every detected pool deserves an API call. Pre-filter on-chain: minimum liquidity threshold, minimum SOL in the pool, deployer blacklist. Call DexScreener only for candidates that pass local heuristics.
• Fallback data sources. When DexScreener throttles you, fall back to Jupiter price API for quote data or Birdeye for token security panels. No single free API covers every field — resilient bots multiplex sources.

Rate limits are the number-one reason Reddit threads ask for DexScreener API alternatives. The API is free but not generous — plan architecture accordingly before you promise sub-second alerts to a Telegram group.

When the DexScreener API rate limits bite or your pipeline needs data it does not expose, these are the alternatives Solana developers actually use in 2026:

API	Best for	Solana new pairs	Pricing	Rate limits
DexScreener API	Pair metadata, boosts, profiles	Indirect — enrich after on-chain detect	Free	~60 req/min (profiles)
Birdeye API	Token security, wallet PnL, OHLCV	New listing endpoints (paid tiers)	Free tier + paid	Tiered by plan
Jupiter API	Swap quotes, routing, execution	Not a discovery tool	Free	Generous for quotes
GeckoTerminal API	Multichain pair data, CoinGecko integration	New pools endpoint (CoinGecko API)	Free tier + paid	CoinGecko rate limits apply
Helius / RPC websockets	Raw on-chain events, fastest detection	Excellent — sub-second pool creation	Free tier + paid RPC	RPC plan dependent

The practical stack for most Solana alert bots in 2026: Helius or QuickNode websocket for detection → DexScreener or Birdeye API for enrichment → Jupiter for execution quotes → uwuu or a manual terminal for the actual trade. No single API does all four jobs well.

Alert bots are the most common production use case for the DexScreener API on Solana. The architecture is well-trodden — dozens of open-source repos on GitHub wrap the same endpoints with TypeScript or Python clients.

A minimal viable alert bot pipeline:

• Detection layer. Solana RPC websocket listening to Raydium AMM program logs, pump.fun migration events, or a curated wallet list from Cielo Finance alerts. This layer outputs mint addresses and pool creation timestamps.
• Enrichment layer. Call DexScreener /latest/dex/tokens/{mint} to pull liquidity, volume, and price change. Apply local filters: minimum $5K liquidity, no freeze authority, deployer not on a known scam list from our rug check Solana workflow.
• Notification layer. Push passing tokens to Telegram, Discord, or a private dashboard. Include DexScreener chart link, Solscan link, and your bot's confidence score.
• Execution layer (optional). Auto-buy via Jupiter swap API, a Telegram trading bot, or copy the wallet that created the pool. This is where DexScreener API data ends and trading infrastructure begins.

Common failure modes we see in alert bot projects: polling DexScreener profiles instead of listening on-chain (misses 80% of launches), ignoring rate limits (bot goes dark during peak hours), and treating API liquidity figures as rug-proof without independent contract checks.

The DexScreener API tells you what happened on a pair — price, volume, liquidity, boosts. It does not tell you what to do next, and it cannot mirror another wallet's trade into your account. That execution gap is the single biggest limitation for Solana traders who discover wallets through DexScreener data.

Consider the workflow: your alert bot detects a new Raydium pool via on-chain logs, enriches it with DexScreener API data, and posts to Telegram. By the time your group reads the alert, opens Phantom, and manually swaps — the wallet that created the pool is already up 10x. The API gave you perfect metadata on a trade you missed.

Three ways traders close this gap in 2026:

• Manual terminals. Axiom, GMGN, Photon, and Padre bundle chart data with one-click buy buttons. Faster than copy-pasting contract addresses into a wallet — but still manual, still fee-per-trade win or lose. See our GMGN review and Axiom review for fee comparisons.
• Telegram trading bots. Trojan, BonkBot, and Maestro fire swaps from chat commands. Sub-second for users already in the chat — but custodial risk, per-trade fees, and no verified leaderboard. Covered in our Telegram trading bot roundup.
• Automated copy trading. Pick a top trader from a verified on-chain leaderboard, connect your wallet non-custodially, and mirror their entries with sub-400ms execution. Performance-based fees mean you pay only when you profit — the opposite of manual terminals that charge on every swap. This is what uwuu.ai built for: close the gap between DexScreener discovery and on-chain execution without writing alert bot code yourself.

The DexScreener API is an excellent discovery and enrichment layer. It was never designed to be an execution layer — and pretending otherwise is how indie bot projects burn months of development time on infrastructure that cannot close a trade.

You do not need to write raw HTTP calls. Community-maintained wrappers abstract endpoint paths and response parsing:

• hedgey-finance/dexscreener-api (TypeScript). The most-starred wrapper on GitHub. Typed responses for pair lookup and search. Note the repo disclaimer: the API is in beta and wrappers may break when DexScreener changes response schemas without notice.
• Python clients. Multiple PyPI packages wrap the same REST routes. Useful for Jupyter-based research notebooks and quick prototyping — less common in production Solana bots that tend toward TypeScript or Rust.
• dltHub source connector. Treats DexScreener as an ETL data source for analytics pipelines. Relevant if you are building a data warehouse, not a live alert bot.

Wrapper or no wrapper, pin your dependency versions and add integration tests that assert response shape. DexScreener has changed field names before without a versioned API announcement — production systems that assume stable schemas wake up to silent failures.

Is the DexScreener API free?

Yes. Standard REST and WebSocket endpoints documented at docs.dexscreener.com require no API key and carry no subscription fee. Rate limits apply — typically around 60 requests per minute on profile endpoints — but there is no paid tier that unlocks unlimited access on the public API as of 2026.

Does the DexScreener API have a new pairs endpoint for Solana?

Not as a dedicated firehose. The retail website's new-pairs feed is a UI feature, not a single REST route. Solana developers detect new pools via on-chain RPC listeners, then call /latest/dex/tokens/{mint} to enrich with DexScreener price and liquidity data once indexed.

What are the DexScreener API rate limits?

Per-endpoint limits are published in the official docs. Token profile and boosted-token routes throttle at roughly 60 requests per minute. Exceeding limits returns HTTP 429. Production bots need caching, deduplication, and exponential backoff — not naive polling loops.

Can I use the DexScreener API for automated trading?

The API is read-only — it returns market data but cannot submit swaps or manage wallets. For execution, pair it with Jupiter for quotes, a Telegram bot for chat-based swaps, or a copy trading platform like uwuu.ai that mirrors verified wallets with sub-400ms execution and performance-based fees.

What is the best DexScreener API alternative for Solana?

It depends on the gap. Birdeye API wins on token security and wallet PnL depth. Helius RPC websockets win on fastest new-pool detection. GeckoTerminal API wins on multichain pair data with CoinGecko integration. Most production Solana stacks use DexScreener for pair metadata plus at least one complementary source.

Do I need a DexScreener API key?

No API key is required for the documented public REST and WebSocket endpoints. Related searches about "DexScreener API key free" often confuse the retail promoted-listings product (a marketing purchase) with API access (which remains keyless for standard routes).

The DexScreener API is the right free starting point for Solana developers building alert bots, dashboards, and pair-enrichment pipelines — and the wrong sole foundation for anyone who needs sub-second trade execution or automated wallet copying. Use it to answer "what is the liquidity, volume, and price on this mint?" after your on-chain stack already detected the pool. Use the DexScreener Solana UI guide when you need human-friendly discovery workflows. Use automated copy trading when you have identified a wallet worth mirroring and cannot afford to manually swap before the move ends.

Build your detection layer on-chain. Enrich with DexScreener. Execute through infrastructure built for speed. That three-layer stack is how Solana traders stop watching perfect setups on a dashboard they cannot act on fast enough.