How to Track New Tokens on Solana, Base, BSC, and 260+ Chains

1
2

requests>=2.31.0
python-dotenv>=1.0.0

1
2

COINGECKO_API_KEY=CG-your_api_key_here
# Optional: add CG_API_MODE=pro if you're using a paid Pro key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import os
import requests
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("COINGECKO_API_KEY")
MODE = os.getenv("CG_API_MODE", "demo")

# Demo and Pro use different base URLs and header names. Pick one and stick to it.
if MODE == "pro":
    BASE_URL = "https://pro-api.coingecko.com/api/v3"
    HEADERS = {"x-cg-pro-api-key": API_KEY}
else:
    BASE_URL = "https://api.coingecko.com/api/v3"
    HEADERS = {"x-cg-demo-api-key": API_KEY}


def get(path, params=None):
    """Call any onchain endpoint on the CoinGecko API."""
    response = requests.get(f"{BASE_URL}{path}", headers=HEADERS, params=params, timeout=20)
    response.raise_for_status()
    return response.json()


def index_included(payload):
    """Index sideloaded entities (tokens, networks, dexes) by ID."""
    return {item["id"]: item for item in payload.get("included", [])}

1
2
3
4
5

from cg_client import get

payload = get("/onchain/networks")
for network in payload["data"][:5]:
    print(network["id"], network["attributes"]["name"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import sys
from cg_client import get, index_included

def fetch_new_pools(network=None, pages=2):
    """Return newest pools. Without a network, fetches across all chains.
    With a network ID, scopes to that chain."""
    if network:
        path = f"/onchain/networks/{network}/new_pools"
        include = "base_token"
    else:
        path = "/onchain/networks/new_pools"
        include = "base_token,network"

    results = []
    for page in range(1, pages + 1):
        payload = get(path, params={"include": include, "page": page})
        included = index_included(payload)
        for pool in payload["data"]:
            attrs = pool["attributes"]
            base_id = pool["relationships"]["base_token"]["data"]["id"]
            base = included[base_id]["attributes"]
            row = {
                "symbol": base.get("symbol"),
                "address": base["address"],
                "reserve_usd": float(attrs.get("reserve_in_usd") or 0),
                "volume_24h": float(attrs.get("volume_usd", {}).get("h24") or 0),
            }
            if network:
                row["network"] = network
                row["network_id"] = network
            else:
                net_id = pool["relationships"]["network"]["data"]["id"]
                row["network"] = included[net_id]["attributes"]["name"]
                row["network_id"] = net_id
            results.append(row)
    return results

if __name__ == "__main__":
    network = sys.argv[1] if len(sys.argv) > 1 else None
    pools = fetch_new_pools(network)[:10]

    header = f"{'NETWORK':<14} {'SYMBOL':<12} {'RESERVE':>14}  {'24H VOLUME':>14}"
    print()
    print(header)
    print("-" * len(header))
    for p in pools:
        print(f"{p['network'][:13]:<14} {(p['symbol'] or '?')[:11]:<12} "
              f"${p['reserve_usd']:>13,.0f}  ${p['volume_24h']:>13,.0f}")
    print()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

from datetime import datetime
from cg_client import get, index_included

def fetch_megafilter():
    """Return new pools across every chain, pre-filtered server-side."""
    payload = get("/onchain/pools/megafilter", params={
        "include": "base_token,network",
        "pool_created_hour_max": 0.1,      # pools created in the last 6 minutes
        "reserve_in_usd_min": 1_000,       # liquidity floor
        "h24_volume_usd_min": 100,         # activity floor
        "checks": "no_honeypot",
        "sort": "pool_created_at_desc",
    })
    included = index_included(payload)
    results = []
    for pool in payload["data"]:
        attrs = pool["attributes"]
        rels = pool["relationships"]
        base = included[rels["base_token"]["data"]["id"]]["attributes"]
        net = included[rels["network"]["data"]["id"]]["attributes"]
        vol = attrs.get("volume_usd") or {}
        chg = attrs.get("price_change_percentage") or {}
        results.append({
            "network": net["name"],
            "symbol": base.get("symbol"),
            "pool_address": attrs.get("address"),
            "price_usd": float(attrs.get("base_token_price_usd") or 0),
            "fdv_usd": float(attrs.get("fdv_usd") or 0),
            "market_cap_usd": float(attrs.get("market_cap_usd") or 0),
            "reserve_usd": float(attrs.get("reserve_in_usd") or 0),
            "volume_5m_usd": float(vol.get("m5") or 0),
            "price_change_5m_pct": float(chg.get("m5") or 0),
            "created_at": attrs["pool_created_at"],
        })
    return results

if __name__ == "__main__":
    pools = fetch_megafilter()

    print("=" * 78)
    print("  NEW POOLS (Megafilter)")
    print("=" * 78)
    print(f"  Generated: {datetime.utcnow().isoformat()}Z")
    print(f"  Window:    past 6 minutes (0.1 hours)")
    print(f"  Filters:   reserve >= $1,000  |  24h volume >= $100  |  no_honeypot")
    print(f"  Matches:   {len(pools)} pools across 250+ chains")
    print("=" * 78)
    print()

    for p in pools:
        mcap = f"${p['market_cap_usd']:,.2f}" if p['market_cap_usd'] else "n/a"
        print(f"  {p['symbol']} ({p['network']})")
        print(f"    Pool       : {p['pool_address']}")
        print(f"    Price      : ${p['price_usd']:,.8f}")
        print(f"    FDV        : ${p['fdv_usd']:,.2f}")
        print(f"    Market Cap : {mcap}")
        print(f"    Reserve    : ${p['reserve_usd']:,.2f}")
        print(f"    5m Volume  : ${p['volume_5m_usd']:,.2f}")
        print(f"    5m Change  : {p['price_change_5m_pct']:+.2f}%")
        print(f"    Created    : {p['created_at']}")
        print()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import json
from pathlib import Path
from fetch_new_pools import fetch_new_pools

SEEN_PATH = Path("seen_pools.json")

def send_alert(pool):
    print(f"NEW: {pool['symbol']} on {pool['network']} — ${pool['reserve_usd']:,.0f}")

seen = set(json.loads(SEEN_PATH.read_text())) if SEEN_PATH.exists() else set()

for pool in fetch_new_pools():
    key = f"{pool['network_id']}:{pool['address']}"
    if key in seen:
        continue
    send_alert(pool)
    seen.add(key)

SEEN_PATH.write_text(json.dumps(sorted(seen)))