# How to see new DEX pairs as they launch

New pools by page, API or WebSocket on Solana and EVM chains — what each feed returns, how far back it goes, and why a new pair says nothing about the token.

*https://cryptomarkets.tools/how-to/find-new-dex-pairs-as-they-launch · next to Crypto Charting Platforms & Screeners*

**Answer:** Ask for pools sorted by creation time. GeckoTerminal's new_pools endpoint and DexPaprika's pool search answer without a key on Solana and EVM chains; Birdeye and Mobula push the same events over a WebSocket on paid plans. DEXTools and DEX Screener show new pairs on a page, but DEX Screener's API has no new-pairs endpoint. Every feed records a contract event: it says a pool exists, not that anyone has checked it.

## Approaches

*In the author’s order. Paid placement does not affect it.*

1. [GeckoTerminal](https://cryptomarkets.tools/tools/geckoterminal.md) — A keyless new_pools endpoint per network or across all of them, 20 pools a page, ten pages, pools from the last 48 hours, cached for a minute.
2. [DexPaprika](https://cryptomarkets.tools/tools/dexpaprika.md) — Pool search sorted by creation time with the filters on the server — created_after, minimum liquidity, DEX — keyless for the first page.
3. [Birdeye Data API](https://cryptomarkets.tools/tools/birdeye-data.md) — A new-listing endpoint on the free plan, and a SUBSCRIBE_NEW_PAIR WebSocket with a liquidity filter from the $199 Premium plan up.
4. [Mobula API](https://cryptomarkets.tools/tools/mobula-api.md) — Pulse views sorted by creation time over REST on every plan with a key; the same views as a stream only on Growth at $400 a month.
5. [DEXTools](https://cryptomarkets.tools/tools/dextools.md) — Live New Pairs is on the free tier of the app; the paid API is priced by freshness, from data 120 seconds old to 15.
6. [DEX Screener](https://cryptomarkets.tools/tools/dex-screener.md) — A new-pairs screen and a pair schema with pairCreatedAt, but no API endpoint that lists new pairs — the API is the lookup after discovery.

## The short way

Ask for pools ordered by creation time, not for tokens. Two indexers answer that without a key,
an account or a wallet:

```text
GET https://api.geckoterminal.com/api/v2/networks/solana/new_pools?include=base_token,quote_token,dex
GET https://api.dexpaprika.com/networks/solana/pools/search?order_by=created_at&sort=desc&limit=50&detailed=true
```

Each row is one pool: its address, the DEX, a creation timestamp, a liquidity figure in dollars and
the two tokens with their contract addresses, names and decimals. Swap `solana` for an EVM chain
using each vendor's own network ID — `eth` on [GeckoTerminal](https://cryptomarkets.tools/tools/geckoterminal), `ethereum` on
[DexPaprika](https://cryptomarkets.tools/tools/dexpaprika) — which their `/networks` endpoints list.

If you would rather watch than poll, the free form of this is a page:
[DEXTools](https://cryptomarkets.tools/tools/dextools)' Live New Pairs, [DEX Screener](https://cryptomarkets.tools/tools/dex-screener)'s new-pairs
screen and GeckoTerminal's new-pools feed. Push delivery over a WebSocket exists and is paid.

The tools below are ordered by how much of the job each does without a key or a browser: a keyless
endpoint that lists new pools first, a page with no such endpoint last.

## What the options are

**A keyless list endpoint.** GeckoTerminal has two: `/networks/{network}/new_pools` and
`/networks/new_pools` across every network it indexes. A pool record carries `address`, `name`,
`pool_created_at`, `reserve_in_usd`, `fdv_usd`, `market_cap_usd`, the price of each side, and
buys, sells and volume from five minutes to 24 hours; `include` adds the tokens (address, name,
symbol, decimals, image and `coingecko_coin_id`) and the DEX. The documentation says data is
updated "as fast as 2-3 seconds" after a transaction confirms, that every endpoint is cached for
one minute, and that the public API is "limited to approximately 10 calls/minute". CoinGecko's
reference for the same endpoint says it covers pools created in the past 48 hours, 20 a page, and
that pages beyond ten need its Analyst plan — page eleven came back 401 saying so on 27 October
2026.

DexPaprika does it as a search: `order_by=created_at` with filters applied on the server —
`created_after` (which takes a relative offset such as `-1h`), `liquidity_usd_min`, volume and
transaction bounds, and `dex_name`; a global `/pools/search` takes a `chains` list. The record
carries the pool `id`, `dex_id`, `chain`, `created_at`, `created_at_block_number`, `liquidity_usd`
and, with `detailed=true`, each token's address, name, symbol, decimals, `total_supply` and
`added_at`. Keyless use is 15 requests a minute and 10,000 credits per IP over a rolling 30 days;
the first page needs no key, and following `next_cursor` past it needs a free one. Both free tiers
are non-commercial, and the free key's data is up to 60 seconds old.

```text
GET https://api.dexpaprika.com/networks/base/pools/search?order_by=created_at&sort=desc&created_after=-1h&liquidity_usd_min=1000&limit=20&detailed=true
```

**A keyed API with a push stream.** [Birdeye](https://cryptomarkets.tools/tools/birdeye-data) has both halves. Over REST,
`/defi/v2/tokens/new_listing` returns tokens rather than pools — `address`, `symbol`, `name`,
`decimals`, `source`, `liquidityAddedAt`, `logoURI` and `liquidity` — one to 20 a call, on every
chain it supports except Sui, at 25 compute units a request. It is on the free Standard plan, whose
30,000 compute units a month are 1,200 such calls.

```bash
curl "https://public-api.birdeye.so/defi/v2/tokens/new_listing?limit=20" \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "x-chain: solana"
```

The push version is the `SUBSCRIBE_NEW_PAIR` WebSocket event, documented for Solana and EVM chains
with Openbook pairs excluded. Each message carries the pool address and name, the `source`, base
and quote token (address, name, symbol, decimals), the creation `txHash` and `blockTime`. The
subscription takes `min_liquidity` and `max_liquidity`; the message itself carries no liquidity
figure. WebSockets start on Premium at $199 a month, and this event is billed at 0.03 compute units
per byte delivered. The documented connection also sets `Origin` and
`Sec-WebSocket-Protocol: echo-protocol` headers.

```text
wss://public-api.birdeye.so/socket/solana?x-api-key=YOUR_API_KEY
{"type": "SUBSCRIBE_NEW_PAIR", "min_liquidity": 100, "max_liquidity": 50000}
```

[Mobula](https://cryptomarkets.tools/tools/mobula-api) calls the same job Pulse. `POST /api/2/pulse` with a chain list and
pool types returns three default views — `new`, sorted by `created_at`; `bonding`; `bonded` — and
custom views take `sortBy`, up to 100 rows and a filter tree. Chains are written `solana:solana` or
`evm:8453`, and pool types range from launchpads such as `pumpfun` to `uniswap-v2`. The docs say
the endpoint is available on all plans, but it wants a key: an unauthenticated call on 27 October
2026 returned 403, "API access is unavailable on the Free plan". The streamed versions — Pulse V2
and a Solana Launchpad stream of pool creations that emits live events only, with no initial sync
— are on Growth and Enterprise.

```bash
curl -X POST "https://api.mobula.io/api/2/pulse" \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"chainId": ["solana:solana"], "poolTypes": ["pumpfun"]}'
```

**A page, and an API that is not the same thing.** DEXTools lists Live New Pairs first among its
free-tier features, and its pair table carries creation time, liquidity and the contract address
beside its own score and audit flag. Its developer API is a separate product on four plans, a $9
trial to $799 a month, whose freshness column runs from data "from 120 sec" old to 15 seconds; the
free API plan is switched off. The developer portal refused our requests on 27 October 2026, so
this page prints no DEXTools request: we could not read its endpoint reference to check one.

DEX Screener is the reverse case. The site has a new-pairs screen; the API has no endpoint that
lists new pairs at all. What it has is a pair schema with `pairCreatedAt` and a `liquidity` object
split into `usd`, `base` and `quote`, behind lookups at 300 requests a minute. That makes it the
second call, not the first — once another feed has given you a token address, this returns every
pool that token trades in, with each one's creation time:

```text
GET https://api.dexscreener.com/token-pairs/v1/{chainId}/{tokenAddress}
```

## Where this breaks

**A new pair is a contract event, not a project.** On the common AMMs, creating a pool is a
permissionless call to a factory contract, and every indexer above lists whatever the factory
emitted. DEX Screener says so in
its own words — tokens are listed "as soon as they are added to a liquidity pool and have at least
one transaction", processed "without any human moderation or intervention". It also follows that a
new pool is not necessarily a new token: on 27 October 2026 an hour of new Base pools in
DexPaprika included an ETH/BTC pool, two assets that are new by no definition. To tell the cases
apart, read the
token's `added_at` on DexPaprika or whether GeckoTerminal returns a `coingecko_coin_id`, or ask DEX
Screener for the token's other pools.

**Liquidity is a reading, and it can leave.** Liquidity can be added and withdrawn in consecutive
transactions, inside one block, and a feed records whatever was in the pool when it read it.
Birdeye's schema is candid about the ambiguity: `liquidity` is "initial or current liquidity in USD
captured for the listing", and `liquidityAddedAt` is when liquidity was first added "or the listing
was first detected". A `min_liquidity` filter on a stream is applied at creation; nothing in a new
pairs feed tells you afterwards that the liquidity has gone. That takes a reserves or trades
subscription on the pool itself.

**The market cap on a pool minutes old is derived from a supply nobody has checked.** GeckoTerminal
returns `market_cap_usd` as null for unverified tokens, and its reference warns that the value
displayed on the site "may match FDV and might not be accurate". DEX Screener computes FDV as total
supply minus burned supply, times price, and switches to a self-reported circulating supply where
one has been submitted. The price in that product is one pool's quote, which
[how to get the price of a DEX pair](https://cryptomarkets.tools/how-to/get-a-dex-pair-price) covers; the supply half is
[how to reconcile supply and market cap](https://cryptomarkets.tools/how-to/reconcile-supply-and-market-cap).

**Safety checks are a separate dataset, and usually a paid one.** None of the creation records
above carries a honeypot, mint-authority or freeze-authority flag. Birdeye's token security
endpoint is a separate call at 30 compute units and is not on the free plan. Mobula's
`/token/security` costs 10 credits; Pulse in asset mode attaches a `security` object, which the
documented example returns empty. GeckoTerminal's `no_honeypot` filter, sourced from GoPlus and
De.Fi, sits on a megafilter endpoint for Analyst plans and above and is "not supported for
Solana". The record telling you a pool exists arrives before anyone has examined it.

**"Trending" and "boosted" are a different ranking, and some of it is bought.** DEX Screener's
Trending Score blends volume, liquidity, transactions, makers and holders with page visitors and
reactions, gives a lift to tokens with verified info, "especially" Enhanced Token Info, and applies
a multiplier for Boosts, which are purchased. Its `/token-boosts` endpoints list what has been
boosted, and `/token-profiles/latest/v1` lists project-supplied profiles, not pools. GeckoTerminal
ranks trending pools by "user engagement on GeckoTerminal", market activity and pool security.
Birdeye's trending endpoint sorts by the criteria you pass, with a `selective` mode its docs call a
newer algorithm without describing it. We found no published method for DEXTools' hot pairs. None
of these lists is in creation order, so sort the new-pools feed yourself.
[What it costs to get a coin listed](https://cryptomarkets.tools/guides/what-it-costs-to-get-a-coin-listed) covers what the
promotional side sells.

**The rate limit binds exactly when launches cluster.** GeckoTerminal's ten calls a minute "may
fluctuate based on network traffic", and the busy minutes are everybody's busy minutes.
DexPaprika's keyless credits are counted per IP, so on a cloud host or a shared office address they
may already be spent. Birdeye's and Mobula's free plans allow one request a second. And the window
moves faster than the limit: ten keyless pages of Solana from GeckoTerminal on 27 October 2026 ran
from 11:05:36 to 11:12:01 UTC. Paging all ten uses a minute's allowance and returns data up to a
minute old, so anything created while you were paging can fall off the end unseen. Deduplicate on
the pool address, never on the symbol. The [rate limit](https://cryptomarkets.tools/glossary/rate-limit) entry explains why
two vendors' figures for it do not compare.

## If you outgrow this

If the problem is **the ten-page window**, the same feed is sold with a key: the
[CoinGecko API](https://cryptomarkets.tools/tools/coingecko-api) serves GeckoTerminal's new pools with unlimited paging from
its Analyst plan, plus a megafilter that sorts by `pool_created_at_desc` and bounds pool age in
hours.

If the problem is **polling**, buy the push: Birdeye's Premium plan or Mobula's Growth plan. Price
the bytes and the minutes before the plan, because both vendors meter the stream itself.

If the problem is **which DEXes count**, read the factory events yourself.
[Bitquery](https://cryptomarkets.tools/tools/bitquery) documents a GraphQL subscription to the `PoolCreated` event of the
Uniswap v3 factory; you name every factory contract you care about, so the definition of "a DEX" is
yours rather than an indexer's. Its card has the limits: events and calls keep three months on EVM
chains and do not exist on Solana, and streaming starts on the $99 Pro plan. A node subscription to
the same event is the version with no decoding and no help — see
[what an Ethereum RPC cannot answer](https://cryptomarkets.tools/guides/what-an-ethereum-rpc-cannot-answer).

And if the question is **historical** — every pool created on a chain last quarter — none of these
is the tool, because none of them is an archive. That is a query, and [Dune](https://cryptomarkets.tools/tools/dune) is where
it runs.

## FAQ

### Does the DEX Screener API have a new pairs endpoint?

No. Its published reference lists pair lookups by address, token-pair and token lookups, search, and five promotional feeds — latest token profiles, community takeovers, ads, latest boosts and top boosts. None of them returns pairs by creation time, and the WebSocket carries only the promotional feeds. The new-pairs list exists on the website, not in the API.

### How far back does a new pools feed go?

Not far, and not as far as the documented limit suggests. GeckoTerminal includes pools created in the past 48 hours but serves ten pages of 20 without a key, which on Solana on 27 October 2026 covered about six and a half minutes. Birdeye's new-listing endpoint accepts a time_to only within the last three days. These are feeds, not archives.

### Is a new pair the same thing as a new token?

No. A pool is created whenever anyone pairs two tokens, so a new pool can belong to a token that has traded for years. DexPaprika returns each token's added_at beside the pool's created_at, and GeckoTerminal returns a coingecko_coin_id for tokens CoinGecko already lists; either tells the two cases apart, and the pool record alone does not.

### Can I get new pairs over a WebSocket for free?

Not from the vendors on this page. Birdeye's SUBSCRIBE_NEW_PAIR starts on the $199-a-month Premium plan, Mobula's Pulse and Launchpad streams on Growth at $400, and DexPaprika's free streams carry prices and reserves, with no new-pool feed at all. Free access to new pools is polling.

## Sources

1. [GeckoTerminal Public API — data freshness, rate limit and the new_pools endpoints](https://api.geckoterminal.com/docs/index.html) — GeckoTerminal, read 2026-10-27
2. [New Pools by Network — 48-hour window, 20 per page, pagination beyond 10 pages](https://docs.coingecko.com/reference/latest-pools-network) — CoinGecko, read 2026-10-27
3. [Megafilter for Pools — creation-time filters and the no_honeypot check](https://docs.coingecko.com/reference/pools-megafilter) — CoinGecko, read 2026-10-27
4. [Trending Pools List — how trending rankings are determined](https://docs.coingecko.com/reference/trending-pools-list) — CoinGecko, read 2026-10-27
5. [Find new crypto pools and token launches](https://docs.dexpaprika.com/tutorials/find-new-pools) — DexPaprika, read 2026-10-27
6. [Rate limits and best practices](https://docs.dexpaprika.com/knowledge-base/rate-limits) — DexPaprika, read 2026-10-27
7. [Token - New listing (GET /defi/v2/tokens/new_listing)](https://data.birdeye.so/docs/data-api/tokenmarket-list/get-defi-v2-tokens-new-listing) — Birdeye, read 2026-10-27
8. [New Pair (SUBSCRIBE_NEW_PAIR)](https://data.birdeye.so/docs/websockets/new-pair) — Birdeye, read 2026-10-27
9. [Pricing and compute unit cost, including WebSocket cost per byte](https://data.birdeye.so/docs/guides/payment/pricing) — Birdeye, read 2026-10-27
10. [Token - Security](https://data.birdeye.so/docs/data-api/security/get-defi-token-security) — Birdeye, read 2026-10-27
11. [Get Pulse - POST Method](https://docs.mobula.io/rest-api-reference/endpoint/pulse-post) — Mobula, read 2026-10-27
12. [Launchpad Stream](https://docs.mobula.io/indexing-stream/stream/websocket/launchpad-stream) — Mobula, read 2026-10-27
13. [Pricing — plans, endpoint credits and WebSocket cost](https://docs.mobula.io/pricing) — Mobula, read 2026-10-27
14. [Premium plans — Free, Standard and Premium feature lists](https://info.dextools.io/) — DEXTools, read 2026-10-27
15. [API Reference — endpoints, rate limits and the pair schema](https://docs.dexscreener.com/api/reference) — DEX Screener, read 2026-10-27
16. [WebSockets — token profiles, community takeovers, ads and boosts](https://docs.dexscreener.com/api/websockets) — DEX Screener, read 2026-10-27
17. [Token Listing — automatic listing, FDV and market cap](https://docs.dexscreener.com/token-listing) — DEX Screener, read 2026-10-27
18. [Trending — what the Trending Score takes into account](https://docs.dexscreener.com/trending) — DEX Screener, read 2026-10-27
19. [Boosting — Boosts apply a multiplier to the Trending Score](https://docs.dexscreener.com/boosting) — DEX Screener, read 2026-10-27
20. [FAQ — data from the chains, no human moderation](https://docs.dexscreener.com/faq) — DEX Screener, read 2026-10-27
21. [Latest trading pairs API — Uniswap v3 PoolCreated events](https://docs.bitquery.io/docs/blockchain/Ethereum/dextrades/latest-trading-pairs-api/) — Bitquery, read 2026-10-27

*Last updated 2026-10-27. Corrected in place — an endpoint that moves is a bug here, not a new post.*