If you've traded on Solana before, you know how quickly new tokens and liquidity pools appear across decentralized exchanges (DEXs). A meme coin can launch, attract liquidity, and start trading within minutes even before mainstream explorers or aggregators pick it up.

The challenge is that Solana's ecosystem is highly fragmented. Different DEXs like Raydium, Orca, Lifinity, and Meteora constantly spin up new markets, each with its own contracts and pools. Relying only on price feeds or token listings means you're always a step behind the actual on-chain activity.

That's why many developers tap directly into blockchain data or use specialized APIs that surface raw pool creation events, liquidity movements, and trading volume in real time. There are multiple ways to access this by running your own Solana RPC and parsing logs or by using APIs that simplify the heavy lifting.

Personally, I prefer Onchain API by Coingecko because it gives free access to real-time DEX data across Solana (and other chains), including newly created pairs and liquidity pool stats. Developer experience is by far the best with Coingecko so I find it much easier to integrate in my tools. And for working prototypes their free limits are pretty good.

In this tutorial, I'll walk you step by step through tracking new Solana pairs and liquidity pools programmatically. We'll explore how to detect fresh token launches, fetch pool-level metrics, and integrate them into your own dashboards or bots. Along the way, I'll share code snippets you can adapt to your workflow.

Setting Up the API

To access real-time market data from CoinGecko, you first need to configure the API correctly. This setup ensures your requests are authenticated and that you receive consistent, reliable responses from the platform.

Overview of Demo vs Pro account

CoinGecko provides two types of API keys: Demo and Pro.

• The Demo key is free to use, suitable for learning, experimentation, and small-scale projects.

• The Pro key is designed for production use, offering higher rate limits, priority access, and additional endpoints.

  Our Amazing Sponsors

  View Website

  DigitalOcean offers a simple and reliable cloud hosting solution that enables developers to get their website or application up and running quickly.

  View Website

  Laravel News keeps you up to date with everything Laravel. Everything from framework news to new community packages, Laravel tutorials, and more.

  View Website

  A Laravel Starter Kit that includes Authentication, User Dashboard, Edit Profile, and a set of UI Components. Learn more about the DevDojo sponsorship program and see your logo here to get your brand in front of thousands of developers.

For most beginners, the demo key is sufficient. Transitioning to Pro later is simple, requiring only minimal adjustments in your configuration which I will include by the end. 

Here's the pricing summary for all of their API plans.

In the demo account we will get access to Onchain DEX Data and around 10k monthly call credits. So, for the scope of this tutorial you can very easily use just the demo API.

Creating a CoinGecko account

To get started, you need a CoinGecko account. The process is simple:

1. Head over to CoinGecko API Homepage.

2. Click on Sign Up.

3. You can register using Google, Apple, or your email address.

Once your account is created, you'll have access to the developer dashboard where API keys can be managed.

Getting your Demo API key

After signing in, follow these steps to generate your first API key:

1. Navigate to the Developer Dashboard.

2. Click on +Add New Key.

3. Label your key (for example: testing, production, or tutorial).

4. Copy the generated key and store it safely as this is what you'll use in your code to authenticate API requests.

5. You can monitor your usage under the Stats section.

Total API Calls (monthly): 10,000

Remaining Calls: 9,994

Last Used: Aug 27, 2025, 20:53 UTC

This information helps you monitor how close you are to hitting your monthly limit.

Making Your First API Call

Once you've generated your API key, the next step is to make your first request. It's important to note that CoinGecko provides separate documentation for Demo and Pro APIs:

• Demo Documentation (free, limited usage): CoinGecko Demo API Docs

• Pro Documentation (higher limits, advanced features): CoinGecko Pro API Docs

This tutorial is based on the Demo API, but the concepts remain the same for Pro. Only the base URL and usage limits differ.

All Demo requests are routed through the following base URL:

https://api.coingecko.com/api/v3

Authentication is done by attaching your Demo API key in the request header. Specifically, you'll use the header field:

x-cg-demo-api-key: <YOUR-DEMO-API-KEY>

The easiest way to test your connection is by calling the Ping endpoint. This confirms that the API is alive and that your key is being accepted.

Here's an example for the Demo API ping:

curl --request GET 
 --url https://api.coingecko.com/api/v3/ping 
 --header 'accept: application/json' 
 --header 'x-cg-demo-api-key: CG-your-api-key'

Expected Response:

{
  "gecko_says": "(V3) To the Moon!"
}

If you see this response, congratulations, You've successfully connected to the CoinGecko Demo API. From here, you can start exploring real data endpoints like market prices, token metadata, and liquidity pools.

New Solana Pool Discovery for DEX

When it comes to tracking new tokens on Solana, I will focus only on DEX (Decentralized Exchange) pools and not centralized exchanges (CEXs). Because unlike CEX listings, which are curated and delayed, DEX pool creation is the very first signal that a new token is entering the market.

On Solana, most new tokens go live on platforms like Pump.fun, Raydium, Orca, or Meteora, and the moment a liquidity pool is created, traders and bots can start swapping. That means if you're watching this API, you're literally seeing the birth of a market in real time before it shows up on larger exchanges.

The dedicated endpoint to fetch new pools by network is:

https://api.coingecko.com/api/v3/onchain/networks/{network}/new_pools

network_id can be replaced with the blockchain you're tracking (e.g., solana, ethereum etc.). In my case it will be solana.

The endpoint gives you newly created pools, refreshed every 60 seconds, sorted by creation timestamp. You will be able to spot where money is flowing the moment a pool opens, without waiting for noisy Telegram calls or influencer pumps.

Let's look at an example request on Solana, where new pool discovery is most often used for token sniping and monitoring liquidity events.

curl --request GET \
 --url https://api.coingecko.com/api/v3/onchain/networks/solana/new_pools \
 --header 'accept: application/json' \
 --header 'x-cg-demo-api-key: YOUR_DEMO_API_KEY'

When you query the /onchain/networks/solana/pools/new endpoint, the API returns a list of newly created liquidity pools on Solana DEX and CEX. Each entry in the response contains technical details like the pool address and token metadata and some financial insights such as current liquidity in USD.

But we only want to query on DEX. So there is a query parameter that we can add to this endpoint

?includes=dex

Here's the final curl request which we need to hit for fetching pools from solana DEX.

curl --request GET \
 --url 'https://api.coingecko.com/api/v3/onchain/networks/solana/new_pools?include=dex' \
 --header 'accept: application/json' \
 --header 'x-cg-demo-api-key: YOUR_DEMO_API_KEY'

The response which we get from the API is:

{
  "data": {
    "id": "solana_2bFuDGsd4HfMjYiVf9Rnw1sSQx153vYzpEwSuvxr5vHR",
    "type": "pool",
    "attributes": {
      "base_token_price_usd": "0.00000768532451919853456680094403031692301101900325616540815266724946",
      "quote_token_price_usd": "213.146619503938422376545485858701595279419816141",
      "quote_token_price_native_currency": "1.0",
      "base_token_price_quote_token": "0.00000003605651611",
      "address": "2bFuDGsd4HfMjYiVf9Rnw1sSQx153vYzpEwSuvxr5vHR",
      "name": "v0y4g3 / SOL",
      "pool_created_at": "2025-08-28T21:00:24Z",
      "fdv_usd": "7685.3245191985",
      "price_change_percentage": {
        "m5": "21.241",
        "h1": "21.241",
        "h6": "21.241",
        "h24": "21.241"
      },
      "transactions": {
        "m5": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        },
        "m15": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        },
        "m30": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        },
        "h1": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        },
        "h6": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        },
        "h24": {
          "buys": 4,
          "sells": 3,
          "buyers": 4,
          "sellers": 2
        }
      },
      "volume_usd": {
        "m5": "1664.1423924829",
        "h1": "1664.1423924829",
        "h6": "1664.1423924829",
        "h24": "1664.1423924829"
      },
      "reserve_in_usd": "5992.6559"
    },
    "relationships": {
      "base_token": {
        "data": {
          "id": "solana_92w4nG5Xsrxcloj4VEj4b97VEbSKPJ1HWGuZm7jH9f1n",
          "type": "token"
        }
      },
      "quote_token": {
        "data": {
          "id": "solana_So11111111111111111111111111111111111111112",
          "type": "token"
        }

This is information about a new liquidity pool on Solana (on pump.fun DEX) for the pair v0y4g3 / SOL. The JSON is structured into attributes (numbers, prices, volume) and relationships (which tokens and DEX it belongs to).

It captures real-time pricing details:

• Base Token (v0y4g3) price in USD: 0.0000076853

• Base Token price in SOL: 0.0000000360

• Quote Token (SOL) price in USD: 213.1466

• Quote Token price in native currency: 1 SOL = 1

This allows traders (and bots) to calculate cross-token valuations instantly.

It also provides the financial weight of the pool:

• FDV (Fully Diluted Valuation): $7,685 → what the token would be worth if its full supply were circulating.

• Market Cap: null (missing because circulating supply isn't yet known)

• Reserve in Pool: $5,992.65 (current liquidity locked in the pool)

• 24h Volume: $1664.14 → (how much was traded within 24 hours).

• Price change across all timeframes (5m → 24h): +21.241%.

With ~$6K liquidity and $1.6K daily volume, this is a tiny and highly speculative market, typical for new meme tokens. The token pumped ~21% within hours of listing. Such volatility is a hallmark of early-stage pools and can signal strong community speculation or bot-driven trading.

Let's take a look at the transaction activity.

• Buys: 4

• Sells: 3

• Unique Buyers: 4

• Unique Sellers: 2

Just 7 trades total, indicating this pool is still at a very early stage. A handful of wallets have interacted, suggesting discovery is still limited to first movers or automated trading bots.

Tracking on a specific DEX

If you want to track only on a specific DEX of your choice (for example pump.fun) then you can use the following endpoint:

/api/v3/onchain/networks/{network}/dexes/{dex}/pools

In my example:

Network : solana

Dex : pump-fun

This endpoint allows you to query all the top pools based on the provided network and decentralized exchange (DEX)

curl --request GET \
 --url https://api.coingecko.com/api/v3/onchain/networks/solana/dexes/pump-fun/pools \
 --header 'accept: application/json' \
 --header 'x-cg-demo-api-key: YOUR_DEMO_API_KEY'

The response will be similar to the earlier endpoint where we used to query for all SOL pairs on every DEX supported by Coinsgecko.

In order to find all the supported DEX for solana network we can query on another On-Chain API.

/api/v3/onchain/networks/{network}/dexes

This endpoint allows you to query all the supported decentralized exchanges (DEXs) based on the provided network.

curl --request GET \
 --url https://api.coingecko.com/api/v3/onchain/networks/solana/dexes \
 --header 'accept: application/json' \
 --header 'x-cg-demo-api-key: YOUR_DEMO_API_KEY'

The response will show us all possible DEXs on solana network like orca, raydium or pump-fun.

{
  "data": [
    {
      "id": "raydium",
      "type": "dex",
      "attributes": {
        "name": "Raydium"
      }
    },
    {
      "id": "orca",
      "type": "dex",
      "attributes": {
        "name": "Orca"
      }
    },
    {
      "id": "pump-fun",
      "type": "dex",
      "attributes": {
        "name": "Pump.fun"
      }
    }
  ]
}

Automation Strategy

To make this practical, I don't just want to pull a single pool's details once but I want an automated workflow that constantly monitors for new liquidity pools as they appear on Solana DEXs like Pump.fun. The goal is to catch opportunities early, before volume and price action move too far.

Polling new pools every few seconds

At the free tier of CoinGecko's API, you typically get 10,000 API calls per month. If you divide that:

• 333 calls per day

• 14 calls per hour

• 1 call every 4 minutes

That's enough for occasional checks but not for real-time tracking. Since Solana liquidity pool data can refresh every 60 seconds, you'd ideally want to poll once every minute (1,440 calls/day). The free tier won't support that as you'll hit the cap quickly.

With CoinGecko Pro, you unlock higher rate limits. For example, at 50,000 calls/month, you can:

• 1,666 calls per day

• 69 calls per hour

• 1 call every minute continuously, with some margin left for alerts and token lookups.

This aligns perfectly with the refresh cycle of pool data, ensuring you're always up to date within a minute of changes.

Switching to CoinGecko Pro

The switch is simple once you have an active subscription.

1. Update the Base URL from Demo host to Pro host

Demo hostname: api.coingecko.com/api/v3

Pro hostname: pro-api.coingecko.com/api/v3

1. Change your API Key in the header for authentication from 

x-cg-demo-api-key to x-cg-pro-api-key.

Everything else (endpoints, parameters) remains the same, so your existing integration won't break.

Conclusion

In conclusion, CoinGecko's Onchain API makes it possible to build a real-time new pool discovery system without relying on third-party dashboards. By polling the new pools by network endpoint at regular intervals, normalizing responses, and storing them in a database, developers can set up automated alerts that notify the moment fresh liquidity pools appear on Solana or other supported chains.

On the free tier, you get 10,000 API calls per month which is sufficient for lightweight monitoring. For production-grade systems that require polling every few seconds, CoinGecko Pro provides higher rate limits, more stability, and guaranteed uptime.

Analysts can benchmark growth trends as they happen, while developers can integrate these feeds into dashboards, bots, or trading algorithms. Ultimately, this approach turns raw on-chain data into actionable market intelligence, giving you not just visibility but also a competitive edge in the decentralized economy.