How to see new DEX pairs as they launch

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:

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, ethereum on DexPaprika — which their /networks endpoints list.

If you would rather watch than poll, the free form of this is a page: DEXTools' Live New Pairs, 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.

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 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.

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.

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

Mobula 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.

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:

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 covers; the supply half is 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 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 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 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 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.

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 is where it runs.