> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dexpaprika.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Find new crypto pools and token launches

> Discover newly created liquidity pools across 35 blockchains. Perfect for finding new tokens, arbitrage opportunities, and emerging DeFi projects early.

## Tutorial overview

Discover newly created liquidity pools by searching pools on each network sorted by `created_at`, with activity filters.

<Info>
  Hitting any snags? We've got your back - [reach out](mailto:support@coinpaprika.com) and we'll help you get this working.
</Info>

## Why monitor new pools?

New liquidity pools are where the action happens in DeFi. They signal new token launches, liquidity migrations, and fresh trading opportunities. Being first to spot them can be a serious advantage.

**What you can catch early:**

* **New token launches** before they hit major trackers
* **Arbitrage opportunities** between pools
* **Liquidity migrations** to better DEXes
* **Emerging projects** before they explode

<Tip>
  **TL;DR**: Jump to [Step 2](#step-2-get-newest-pools) if you want to start pulling new pools immediately.
</Tip>

***

## Step 1: Pick your networks

First, see what blockchains you want to monitor using the [Networks API](/api-reference/networks/get-a-list-of-available-blockchain-networks):

```bash theme={null}
curl "https://api.dexpaprika.com/networks" | jq '.[] | {id: .id, name: .display_name}'
```

***

## Step 2: Get newest pools

Here's the money shot - getting pools sorted by creation date using the pool search endpoint:

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&limit=10&detailed=true" | jq
```

### What these parameters do:

| Parameter             | Effect                                                    | Pro Tip                                                          |
| --------------------- | --------------------------------------------------------- | ---------------------------------------------------------------- |
| `order_by=created_at` | Sort by when pool was made                                | Only way to find truly new pools                                 |
| `sort=desc`           | Newest first                                              | Use `asc` for historical analysis                                |
| `limit=10`            | How many pools back                                       | Max is 100, but 10-20 is usually enough                          |
| `cursor`              | Pagination                                                | Pass `next_cursor` from the previous response for deeper history |
| `detailed=true`       | Include full token metadata (symbol, name) in each result | Add it whenever you display token symbols                        |

### What you get:

```json theme={null}
{
  "results": [
    {
      "id": "0x462229e7fc9e6cab0ebbd643cc6dfef2a5261ee9",
      "dex_name": "Uniswap V2",
      "created_at": "2025-06-09T09:28:35Z",
      "volume_usd_24h": 767.17,
      "transactions_24h": 5,
      "tokens": [
        { "symbol": "🧸TEDDYS", "name": "🧸TeddySwap" },
        { "symbol": "WETH", "name": "Wrapped Ether" }
      ]
    }
  ],
  "has_next_page": true,
  "next_cursor": "eyJvZmZzZXQiOjEwfQ=="
}
```

<Note>
  To screen multiple networks in one call, use the global `GET /pools/search` with a `chains` filter, for example `chains=ethereum,base,solana`.
</Note>

**Red flags to watch for:**

* Zero transactions after hours (might be a test pool)
* Very low liquidity relative to volume (possible wash trading)

***

## Focus on specific DEXes

Want to monitor just Uniswap or Raydium? First get the DEX list using the [Network DEXes API](/api-reference/dexes/get-a-list-of-available-dexes-on-a-network):

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/dexes" | jq '.[] | {id: .id, name: .name}'
```

Then list new pools by DEX using the [DEX Pools API](/api-reference/pools/get-top-x-pools-on-a-networks-dex):

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/dexes/uniswap_v3/pools?order_by=created_at&sort=desc&limit=10" | jq
```

***

## Multi-chain monitoring

Real pros monitor multiple chains simultaneously. Here's how:

### Ethereum

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&limit=5&detailed=true" | jq '.results[] | {chain: "ethereum", pool: .id, created: .created_at, volume: .volume_usd_24h, tokens: [.tokens[].symbol]}'
```

### Solana

```bash theme={null}
curl "https://api.dexpaprika.com/networks/solana/pools/search?order_by=created_at&sort=desc&limit=5&detailed=true" | jq '.results[] | {chain: "solana", pool: .id, created: .created_at, volume: .volume_usd_24h, tokens: [.tokens[].symbol]}'
```

### Base

```bash theme={null}
curl "https://api.dexpaprika.com/networks/base/pools/search?order_by=created_at&sort=desc&limit=5&detailed=true" | jq '.results[] | {chain: "base", pool: .id, created: .created_at, volume: .volume_usd_24h, tokens: [.tokens[].symbol]}'
```

Or all three in one request:

```bash theme={null}
curl "https://api.dexpaprika.com/pools/search?chains=ethereum,solana,base&order_by=created_at&sort=desc&limit=15" | jq '.results[] | {chain: .chain, pool: .id, created: .created_at, volume: .volume_usd_24h}'
```

**Pro tip**: Use different limits based on chain activity. Solana might need `limit=20` because of memecoin amounts, while Ethereum `limit=5` catches the important stuff.

***

## Smart filtering strategies

### Only high-activity pools

Skip the dead pools - focus on ones with real trading:

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&volume_usd_24h_min=1000&txns_24h_min=10&limit=50" | jq '.results[] | {id: .id, created: .created_at, volume: .volume_usd_24h, txns: .transactions_24h}'
```

### Last 24 hours only

Filter server-side by creation time to get super fresh pools:

```bash theme={null}
# Pools created in the last 24 hours
DAY_AGO=$(python3 -c "import time; print(int(time.time()) - 86400)")
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&created_after=$DAY_AGO&limit=100" | jq '.results[] | {id: .id, age: .created_at, volume: .volume_usd_24h}'
```

### New token launches

Look for pools where the tokens themselves are brand new:

```bash theme={null}
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&limit=20&detailed=true" | jq '.results[] | select(.tokens[] | .added_at > "2025-01-25T00:00:00Z") | {pool: .id, pool_age: .created_at, new_tokens: [.tokens[] | select(.added_at > "2025-01-25T00:00:00Z") | .symbol]}'
```

***

## Production monitoring setup

### Simple monitoring script

Here's a bash script that checks for new pools every 5 minutes:

```bash theme={null}
#!/bin/bash

# Monitor new pools across multiple chains
CHAINS=("ethereum" "solana" "base")
MIN_VOLUME=5000

while true; do
    echo "🔍 Checking for new pools at $(date)"
    
    for chain in "${CHAINS[@]}"; do
        echo "--- $chain ---"
        
        # Get new pools with decent volume
        curl -s "https://api.dexpaprika.com/networks/$chain/pools/search?order_by=created_at&sort=desc&volume_usd_24h_min=$MIN_VOLUME&limit=10&detailed=true" | \
        jq '.results[] | {
            pool_id: .id,
            chain: "'$chain'",
            created: .created_at,
            volume: .volume_usd_24h,
            tokens: [.tokens[].symbol]
        }'
    done
    
    echo "⏰ Sleeping for 5 minutes..."
    sleep 300
done
```

### Alert on high-volume new pools

Catch the big moves automatically:

```bash theme={null}
# Check for new pools with serious volume
NEW_POOLS=$(curl -s "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&volume_usd_24h_min=50000&limit=20" | jq '.results[]')

if [ -n "$NEW_POOLS" ]; then
    echo "🚨 HIGH VOLUME NEW POOL DETECTED!"
    echo "$NEW_POOLS"
    # Add your notification here (Discord webhook, Slack, email, etc.)
    # curl -X POST "YOUR_DISCORD_WEBHOOK" -d "{\"content\": \"New high-volume pool: $NEW_POOLS\"}"
fi
```

***

## Troubleshooting common issues

### "No new pools found"

Check if you're looking at the right timeframe:

```bash theme={null}
# See when the last pool was created
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?order_by=created_at&sort=desc&limit=1" | jq '.results[0].created_at'
```

### "Too much spam"

Filter out low-quality pools with volume and transaction thresholds:

```bash theme={null}
# More restrictive filtering
curl "https://api.dexpaprika.com/networks/solana/pools/search?order_by=created_at&sort=desc&txns_24h_min=20&volume_usd_24h_min=5000&limit=50" | jq '.results[]'
```

To screen by token valuation (for example, only new tokens under a \$100M FDV), use the token search endpoint, which supports `fdv_usd_max`:

```bash theme={null}
curl "https://api.dexpaprika.com/networks/solana/tokens/search?order_by=created_at&sort=desc&fdv_usd_max=100000000&limit=25" | jq '.results[] | {token: .address, fdv: .fdv_usd, volume: .volume_usd_24h}'
```

### "Missing opportunities"

You might need to check more frequently or cast a wider net:

```bash theme={null}
# Check multiple DEXes on one chain
for dex in uniswap_v3 uniswap_v2 sushiswap; do
    echo "=== $dex ==="
    curl -s "https://api.dexpaprika.com/networks/ethereum/dexes/$dex/pools?order_by=created_at&sort=desc&limit=3" | jq '.pools[0] | {dex: "'$dex'", created: .created_at, tokens: [.tokens[].symbol]}'
done
```

***

## What's next?

<CardGroup cols={2}>
  <Card title="Historical Price Data" icon="chart-line" href="/tutorials/retrieve-historical-data">
    Analyze new pools with price history.
  </Card>

  <Card title="Pool Transactions" icon="exchange-alt" href="/api-reference/pools/get-transactions-of-a-pool-on-a-network-paging-can-be-used-up-to-100-pages">
    Monitor trading activity in real-time.
  </Card>
</CardGroup>

<CardGroup cols={2}>
  <Card title="Pool Details API" icon="info-circle" href="/api-reference/pools/get-a-pool-on-a-network">
    Get comprehensive pool information and metadata.
  </Card>

  <Card title="Search API" icon="search" href="/api-reference/search/search-for-tokens-pools-and-dexes">
    Find pools, tokens, and DEXes across all networks.
  </Card>
</CardGroup>

## Need help?

<CardGroup cols={2}>
  <Card title="Developer Discord" icon="discord" href="https://discord.gg/DhJge5TUGM">
    Share strategies and get help from other builders.
  </Card>

  <Card title="Direct Support" icon="message" href="mailto:support@coinpaprika.com">
    Stuck on something? We'll help you figure it out.
  </Card>
</CardGroup>

### FAQs

<AccordionGroup>
  <Accordion title="How do I reliably detect new pools?">
    Sort by `created_at` descending and set a reasonable `limit`. Poll periodically and de-duplicate by pool id.
  </Accordion>

  <Accordion title="What filters reduce spam?">
    Combine `volume_usd_24h_min` and `txns_24h_min` thresholds; optionally whitelist DEXes or networks.
  </Accordion>

  <Accordion title="How can I monitor multiple chains efficiently?">
    Use the global `GET /pools/search` with `chains=ethereum,base,solana`, or run parallel per-network requests and merge by a timestamp key.
  </Accordion>

  <Accordion title="Can I alert on high-volume launches?">
    Yes. Query newest pools and alert when `volume_usd_24h` exceeds your threshold.
  </Accordion>
</AccordionGroup>

<script type="application/ld+json">
  {JSON.stringify({
      "@context": "https://schema.org",
      "@type": "FAQPage",
      "mainEntity": [
        {"@type": "Question","name": "How do I reliably detect new pools?","acceptedAnswer": {"@type": "Answer","text": "Sort by created_at desc, poll, and de-duplicate by pool id."}},
        {"@type": "Question","name": "What filters reduce spam?","acceptedAnswer": {"@type": "Answer","text": "Use volume_usd_24h_min and txns_24h_min thresholds; optionally whitelist DEXes."}},
        {"@type": "Question","name": "How can I monitor multiple chains efficiently?","acceptedAnswer": {"@type": "Answer","text": "Use the global /pools/search with a chains filter, or run parallel per-network requests and merge by timestamp."}},
        {"@type": "Question","name": "Can I alert on high-volume launches?","acceptedAnswer": {"@type": "Answer","text": "Yes. Alert when newest pools exceed your volume_usd_24h threshold."}}
      ]
    })}
</script>