DEXTools API: Endpoints, Pricing & Alternatives (2026)

DEXTools API is the programmatic access layer behind one of crypto's oldest multichain DEX charting platforms — a set of authenticated REST endpoints that let developers pull live pair data, pool rankings, maker/taker feeds, and token metadata across 80+ blockchains without scraping the retail website. On Solana specifically, builders use the DEXTools API to monitor hot pairs, enrich alert bots with OHLC snapshots, and cross-reference pool liquidity before routing a swap. What most developers never learn is where the API stops being useful: it is a read-only analytics layer with tiered pricing, no execution hooks, and no wallet-copy infrastructure — and the gap between detecting a trending pair via API and mirroring the wallet that bought it first is where automated Solana traders either win or bleed latency in 2026.

Most DEXTools API coverage online is the official developer portal, a Python wrapper README on GitHub, or a generic "beginner's guide" that lists endpoints without Solana context. Few articles answer the questions active builders and traders actually search: Does DEXTools have an API? Is the DEXTools API free? How do you get a DEXTools API key? What does each endpoint return for Solana pairs? How does it compare to the DexScreener API? And what do you use when the API surfaces a wallet worth copying but cannot fire the trade? This guide maps the DEXTools API architecture, documents real pricing and rate-limit behavior, compares alternatives, and shows where the API fits in the research-to-execution stack alongside our DEXTools alternative comparison and DexScreener Solana UI guide.

The DEXTools API is a commercial HTTP interface to DEXTools' indexed DEX data across Ethereum, BNB Chain, Base, Polygon, Arbitrum, Solana, and dozens of other networks. Unlike the retail website — which renders charts, hot-pair feeds, and social sentiment overlays for human traders — the API returns structured JSON for programmatic consumption: pair rankings, price snapshots, liquidity metrics, transaction feeds, and token metadata keyed by chain and contract address.

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

• REST endpoints (API V2). Authenticated GET requests to api.dextools.io return pair data, rankings, and token lookups. DEXTools API V2 expanded support to 80+ blockchains including both EVM and non-EVM networks — Solana is explicitly supported alongside Ethereum L2s. Each request requires an API key obtained through the developer portal at developer.dextools.io.
• Ranking and discovery feeds. DEXTools exposes hot pairs, gainers, and network-specific pool rankings that power the retail "DEXTboard" experience. Developers poll these endpoints to surface trending tokens programmatically — the closest DEXTools equivalent to DexScreener's boosted-token lists.
• Pair and token lookup. Query by token contract address or pair address to retrieve price, liquidity, volume, transaction counts, and maker/taker markers aggregated from on-chain swap events. This is the endpoint most multichain alert bots call after detecting a new pool elsewhere.

The DEXTools 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, Jupiter routing, Telegram bots, or a purpose-built Solana copy trading bot when speed matters more than chart UX.

Direct answer: the DEXTools API is legit, genuinely useful for multichain pair metadata and ranking feeds, but paid, rate-limited, and insufficient as a standalone trading stack for Solana memecoin hunters who need sub-second execution. API access requires registration at developer.dextools.io and a paid tier — unlike DexScreener's keyless free API. DEXTools shines when you need structured pair data across multiple EVM chains from one vendor — not when you need to copy a wallet before a bonding curve completes on Solana.

Category	Verdict	Notes
Price	Paid tiers	API key required — register at developer.dextools.io
Multichain pair data	Very good	80+ blockchains in API V2 — strong EVM coverage
Solana pair lookup	Good	Indexed Raydium/Orca pools — lags pump.fun bonding-curve stage
Hot pair rankings	Excellent	Core DEXTools differentiator vs raw pair lookup APIs
Rate limits	Tier-dependent	Higher tiers unlock more requests — plan caching regardless
Automated copy trading	Not offered	Pair with copy trade on Solana infrastructure

Yes — DEXTools launched a public API with Version 2 supporting 80+ blockchains as documented at developer.dextools.io and info.dextools.io. The API is a separate product from the retail charting website: you register for developer access, obtain an API key, and call authenticated REST endpoints to pull pair data programmatically.

What the DEXTools API does and does not include:

• Included with API access. Pair rankings by chain, token and pool lookups by contract address, price and liquidity snapshots, transaction feed metadata, and multichain hot-pair discovery. These cover most dashboard backends and cross-chain alert bots.
• Not included. Retail premium charting features (custom indicators, social overlays) are website-only. Swap execution, wallet management, and copy-trading hooks do not exist in any DEXTools API tier. Historical OHLC exports beyond what pair endpoints return may require higher tiers or separate data products.
• Key difference from DexScreener. The DexScreener API is free and keyless for standard routes. DEXTools API requires registration and paid access — a trade-off for deeper ranking feeds and multichain consistency from a single vendor.

If you only need Solana pair metadata without multichain ranking feeds, DexScreener's free API often covers the same enrichment layer at lower cost. DEXTools API earns its subscription when you run one backend across Ethereum, Base, BNB Chain, and Solana and want unified ranking logic from a single data provider.

Direct answer: the DEXTools API is not free — you need to register at developer.dextools.io and select a paid tier to obtain an API key. DEXTools does not publish unlimited free API access comparable to DexScreener. Pricing tiers scale by request volume, endpoint access, and support level. Exact dollar amounts change — check the developer portal for current plans rather than relying on outdated blog posts.

How to get a DEXTools API key in 2026:

• Step 1: Register. Create a developer account at developer.dextools.io. You will need an email and basic project description explaining your use case (dashboard, alert bot, analytics pipeline).
• Step 2: Select a plan. Choose a tier matching your expected request volume. Indie alert bots polling rankings every 30 seconds burn through quotas faster than batch enrichment pipelines that call pair lookup only on on-chain events.
• Step 3: Authenticate requests. Pass your API key in request headers as documented in the DEXTools API V2 reference. Community Python wrappers like alb2001/dextools-python on GitHub abstract header management for quick prototyping.
• Step 4: Monitor usage. Track request counts against your tier limit. Exceeding quotas triggers throttling or overage charges depending on your plan — plan caching and deduplication from day one.

Related searches like "dextools api free" often confuse the retail website's free charting tier with API access. The website lets you view charts without paying; the API is a developer product with separate billing. If your budget is zero, start with DexScreener's free API or GeckoTerminal's CoinGecko-integrated endpoints before committing to DEXTools API spend.

Direct answer: the endpoints that matter for Solana and multichain builders cluster around pair lookup, ranking feeds, token metadata, and chain-specific pool discovery. DEXTools documents these at developer.dextools.io. Below is a practical map — not a verbatim copy of the docs, but a trader-oriented guide to which routes solve which problems.

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

The workhorse endpoint family: pass a chain identifier and token or pool contract address, receive price, liquidity, volume, transaction counts, and maker/taker markers. On Solana, this covers Raydium, Orca, Meteora, and other indexed DEX pools once DEXTools has ingested the on-chain data.

Use case: after your on-chain listener detects a new Raydium pool, call the pair lookup endpoint to enrich it with DEXTools' aggregated metrics before deciding whether to trade. Same pattern as DexScreener's /latest/dex/tokens/{mint} route — but behind an authenticated API key and paid tier.

Hot pairs and ranking feeds {#ranking-feeds-endpoint}

DEXTools' ranking endpoints return trending pairs, gainers, and network-filtered hot lists — the programmatic version of the retail DEXTboard. This is where DEXTools API differentiates from pure pair-lookup APIs: you get curated "what is moving now" feeds without building your own volume-ranking logic.

Use case: poll Solana hot pairs every 60 seconds, diff against a local cache, and fire Telegram notifications on new entries crossing a volume threshold. Limitation: ranking speed on fresh pump.fun migrations often lags Solana-native terminals — DexScreener, GMGN, and Photon index bonding-curve stage tokens faster than DEXTools' multichain pipeline.

Token metadata and social links {#token-metadata-endpoint}

Token endpoints return name, symbol, decimals, social links, and holder-adjacent metadata that DEXTools aggregates from on-chain registries and community submissions. Useful for dashboard UIs that need human-readable labels alongside raw contract addresses.

Transaction and maker/taker feeds {#transaction-feed-endpoint}

Pair pages on the retail site show buy/sell markers on charts. The API exposes transaction-level data for programmatic consumption — alert bots use this to detect large buys ("whale entries") on a pair your ranking feed surfaced. For deeper wallet PnL leaderboards, layer Birdeye or tools from our wallet tracker comparison.

Chain and DEX enumeration {#chain-enumeration-endpoint}

API V2's 80+ blockchain support means endpoints accept chain identifiers for Ethereum, Base, Arbitrum, Solana, and more. Enumeration endpoints list supported chains and DEX protocols — critical when you build one alert backend that serves multiple networks without hardcoding chain IDs.

Solana is a supported chain in DEXTools API V2, but the API reflects DEXTools' Solana indexer speed — not raw on-chain event timing. Understanding this distinction prevents the most common integration mistake: treating DEXTools rankings as a real-time new-pool firehose when they are a curated trending layer with indexing lag.

How Solana developers actually use the DEXTools API in 2026:

• On-chain listener + DEXTools enrichment. Run a Solana RPC websocket subscription to Raydium, Orca, or pump.fun program logs. When a new pool event fires, call DEXTools pair lookup to pull price, liquidity, and volume snapshot. Standard architecture — identical pattern to DexScreener enrichment, different vendor.
• Ranking feed polling. Poll Solana hot pairs every 60–120 seconds and alert on tokens crossing volume or liquidity thresholds. Catches momentum plays after initial discovery — misses sub-minute bonding-curve entries that Solana-native tools surface first.
• Cross-chain dashboard backend. If your product serves Ethereum degens and Solana memecoin hunters from one UI, DEXTools API V2 gives you one authentication layer and consistent response schemas across chains. DexScreener and Birdeye also support multichain — compare pricing and Solana indexing speed before committing.
• Retail UI for discovery, API for metadata. Many profitable traders use the DEXTools alternative stack for human scanning — DexScreener new-pairs tab, GMGN wallet feeds — and reserve the DEXTools API for enriching alerts their on-chain stack already triggered.

Latency reality on Solana: DEXTools indexes most established Raydium and Orca pools reliably but may lag on pump.fun bonding-curve tokens 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, then layer our rug check Solana workflow before sizing a position.

DEXTools API rate limits scale with your paid tier — higher plans unlock more requests per minute and broader endpoint access. Unlike DexScreener's published per-route limits, DEXTools ties throttling to your subscription. The universal production advice still applies regardless of vendor.

Patterns that keep your Solana alert bot alive on the DEXTools API:

• Cache responses locally. Store pair snapshots in Redis or SQLite with a 30–60 second TTL. Serve your dashboard from cache; refresh from DEXTools 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 throttling. When rate-limited, back off 2s → 4s → 8s rather than hammering the endpoint. Paid tiers still enforce ceilings — sustained overages cost money or get your key suspended.
• 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 DEXTools only for candidates that pass local heuristics.
• Fallback data sources. When DEXTools throttles you or a Solana pool is not yet indexed, fall back to DexScreener's free pair lookup, Jupiter price API for quotes, or Solscan for raw on-chain state. No single API covers every field — resilient bots multiplex sources.

Rate limits and paid tiers are the number-one reason traders search for DEXTools API alternatives. Budget for API costs before you promise sub-second alerts to a Telegram group — and always maintain a free fallback source for enrichment when quotas run dry.

The most common question in DEXTools API searches is how it compares to DexScreener — two platforms that look similar on the retail side but differ sharply on API access, pricing, and Solana indexing behavior:

Factor	DEXTools API	DexScreener API
Pricing	Paid tiers — API key required	Free — no key for standard routes
Multichain ranking feeds	Strong — core product strength	Moderate — boosted tokens, not full rankings
Solana fresh launches	Good on indexed pools — lags bonding-curve stage	Good — similar indexer lag pattern
Pair lookup by address	Excellent — authenticated, consistent schemas	Excellent — free, ~60 req/min on profiles
Best for	Multichain dashboards, ranking bots, EVM+Solana backends	Indie Solana alert bots, free enrichment pipelines

Practical recommendation for Solana-only builders in 2026: start with the free DexScreener API for pair enrichment. Add DEXTools API only if you need unified ranking feeds across multiple chains from one vendor, or if your product already pays for DEXTools retail premium and bundles API access. For wallet discovery depth beyond pair metadata, layer smart money crypto tools — neither API ranks wallets by realized PnL.

Alert bots are a common production use case for the DEXTools API on Solana and multichain backends. The architecture mirrors DexScreener integrations — with the added step of API key management and quota monitoring.

A minimal viable alert bot pipeline using DEXTools API:

• Detection layer. Solana RPC websocket listening to Raydium AMM program logs, pump.fun migration events, or a curated wallet list from Cielo Finance alerts. Outputs mint addresses and pool creation timestamps.
• Enrichment layer. Call DEXTools pair lookup to pull liquidity, volume, and price change. Apply local filters: minimum liquidity threshold, no freeze authority, deployer not on a known scam list. Optionally cross-check DexScreener's free API as a fallback when DEXTools has not indexed the pool yet.
• Ranking layer (DEXTools-specific). Poll hot pair rankings to catch momentum tokens your on-chain listener missed. Diff against cache; alert on new entries crossing volume thresholds. This layer has no DexScreener equivalent at the same ranking depth without building custom logic.
• Notification layer. Push passing tokens to Telegram, Discord, or a private dashboard. Include chart links, Solscan explorer links, 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 DEXTools API data ends and trading infrastructure begins.

Common failure modes: polling DEXTools rankings instead of listening on-chain (misses early launches), ignoring paid tier quotas (bot goes dark during peak hours), and treating API liquidity figures as rug-proof without independent contract checks from our memecoin trading playbook.

The DEXTools API tells you what is trending on a pair — price, volume, liquidity, rankings. 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 DEXTools data.

Consider the workflow: your ranking feed surfaces a hot Solana pair, your enrichment layer confirms liquidity looks real, and your Telegram group gets the alert. By the time someone opens Phantom and manually swaps — the wallet that started the move 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 — 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 at uwuu.ai/leaderboard, connect your wallet non-custodially, and mirror their entries with sub-400ms execution. Performance-based fees mean you pay only when you profit. This is what uwuu.ai built for: close the gap between DEXTools discovery and on-chain execution without writing alert bot code yourself.

The DEXTools API is an excellent analytics and ranking 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, authentication headers, and response parsing:

• alb2001/dextools-python (Python). The most-referenced wrapper on GitHub. Supports DEXTools API v1 and v2 with typed methods for pair lookup and rankings. Install via pip for Jupyter notebooks and quick prototyping.
• TypeScript and Node clients. Fewer mature community wrappers than DexScreener's ecosystem — most production Solana bots write thin fetch wrappers around the V2 REST routes with explicit API key header management.
• Custom middleware. Teams running multichain products often build an internal abstraction that normalizes DEXTools, DexScreener, and Birdeye responses into one schema — so alert logic does not break when one vendor throttles or lags on indexing.

Wrapper or no wrapper, pin dependency versions and add integration tests that assert response shape. DEXTools has shipped API V2 with expanded chain support — production systems that assume v1 schemas wake up to silent failures after migrations.

Does DEXTools have an API?

Yes. DEXTools offers a public API (Version 2) supporting 80+ blockchains including Solana. Register at developer.dextools.io to obtain an API key and access authenticated REST endpoints for pair data, rankings, and token metadata.

Is the DEXTools API free?

No. Unlike the DexScreener API, DEXTools API access requires a paid developer tier. The retail website offers free charting, but programmatic API access is a separate product with its own pricing. Check developer.dextools.io for current plans.

How do I get a DEXTools API key?

Create a developer account at developer.dextools.io, select a plan matching your request volume, and use the issued API key in your request headers. Community Python wrappers like dextools-python handle authentication automatically once you configure the key.

What is the difference between DEXTools API and DexScreener API?

DEXTools API is paid, requires an API key, and excels at multichain ranking feeds from one vendor. DexScreener API is free for standard routes, keyless, and popular for indie Solana alert bot enrichment. Both are read-only — neither executes swaps or copies wallets.

Can I use the DEXTools API for automated trading on Solana?

The API is read-only — it returns market data and rankings 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 DEXTools API alternative for Solana?

For free pair enrichment, the DexScreener API is the default starting point. For fastest new-pool detection, Helius RPC websockets beat any charting API. For wallet PnL depth, Birdeye wins. For multichain ranking feeds without building custom logic, DEXTools API remains competitive if you already pay for access. Most production stacks combine at least two sources.

The DEXTools API is the right choice for multichain developers who need unified ranking feeds and pair metadata from one authenticated vendor — and the wrong sole foundation for Solana-only builders on a zero budget or anyone who needs sub-second trade execution. Use it to answer "what is trending across my supported chains?" and enrich on-chain detections with structured pair data. Use the DEXTools alternative guide when you need retail UI comparisons. Use the DexScreener API guide when free enrichment is enough. 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 DEXTools or 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.