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

# Filter and screen liquidity pools

> Use the DexPaprika pool search endpoint to find pools by volume, liquidity, transaction count, and creation date. Build pool screeners, find high-activity pools, and discover recently launched tokens.

## What you'll build

A pool screener that finds liquidity pools matching specific criteria: volume thresholds, liquidity, transaction counts, and creation dates. This is useful for:

* Finding high-activity pools on any network
* Discovering newly created pools (early token launches)
* Building automated pool monitoring pipelines
* Filtering noise from low-activity pools

<Warning>
  This tutorial uses `GET /networks/{network}/pools/search`. It replaces the old `/networks/{network}/pools/filter`, `/networks/{network}/pools`, and `/pools` endpoints, which were removed and now return `410 Gone`. If you used the old endpoints, see the parameter changes below.
</Warning>

***

## The search endpoint

```
GET /networks/{network}/pools/search
```

Combine multiple filters with AND logic. Results are returned in a `results` array with cursor-based pagination. To search across several networks at once, use the global `GET /pools/search` with a `chains` parameter.

### Available parameters

| Parameter                                  | Type    | Description                                                                                                                                |
| ------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `volume_usd_24h_min` / `_max`              | number  | 24h volume in USD                                                                                                                          |
| `volume_usd_7d_min` / `_max`               | number  | 7d volume in USD                                                                                                                           |
| `volume_usd_30d_min` / `_max`              | number  | 30d volume in USD                                                                                                                          |
| `liquidity_usd_min` / `_max`               | number  | Pool liquidity in USD                                                                                                                      |
| `txns_24h_min` / `_max`                    | integer | Transactions in last 24h                                                                                                                   |
| `price_usd_min` / `_max`                   | number  | Pool price in USD                                                                                                                          |
| `price_change_percentage_24h_min` / `_max` | number  | 24h price change, percent                                                                                                                  |
| `created_after` / `created_before`         | integer | UNIX timestamp window                                                                                                                      |
| `dex_name`                                 | string  | Restrict to a single DEX                                                                                                                   |
| `order_by`                                 | string  | `volume_usd_24h`, `volume_usd_7d`, `volume_usd_30d`, `liquidity_usd`, `txns_24h`, `created_at`, `price_usd`, `price_change_percentage_24h` |
| `sort`                                     | string  | `asc` or `desc`                                                                                                                            |
| `limit`                                    | integer | Items per page (default 10)                                                                                                                |
| `cursor`                                   | string  | Pass `next_cursor` from the previous response to page forward                                                                              |

<Note>
  Parameter names migrated from the old filter endpoint: `volume_24h_min` is now `volume_usd_24h_min`, `sort_by` is now `order_by`, `sort_dir` is now `sort`, and `page` is replaced by `cursor`. The `volume_7d`, `volume_30d`, and `liquidity_usd` filters are now functional.
</Note>

***

## Example 1: High-volume pools on Ethereum

Find Ethereum pools with over \$500,000 in daily volume:

<CodeGroup>
  ```bash bash theme={null}
  curl "https://api.dexpaprika.com/networks/ethereum/pools/search?volume_usd_24h_min=500000&order_by=volume_usd_24h&sort=desc&limit=5"
  ```

  ```python python theme={null}
  import requests

  response = requests.get("https://api.dexpaprika.com/networks/ethereum/pools/search", params={
      "volume_usd_24h_min": 500000,
      "order_by": "volume_usd_24h",
      "sort": "desc",
      "limit": 5
  })

  data = response.json()

  for pool in data["results"]:
      print(f"  {pool['dex_name']} | {pool['id'][:16]}... | Vol: ${pool['volume_usd_24h']:,.0f} | Txns: {pool['transactions_24h']}")

  if data["has_next_page"]:
      print(f"Next page cursor: {data['next_cursor']}")
  ```

  ```javascript javascript theme={null}
  const response = await fetch(
    "https://api.dexpaprika.com/networks/ethereum/pools/search?" +
    new URLSearchParams({
      volume_usd_24h_min: 500000,
      order_by: "volume_usd_24h",
      sort: "desc",
      limit: 5
    })
  );

  const data = await response.json();

  data.results.forEach(pool => {
    console.log(`  ${pool.dex_name} | ${pool.id.slice(0, 16)}... | Vol: $${pool.volume_usd_24h.toLocaleString()} | Txns: ${pool.transactions_24h}`);
  });
  ```
</CodeGroup>

### Response format

```json theme={null}
{
  "results": [
    {
      "chain": "ethereum",
      "id": "0xf6e72db5454dd049d0788e411b06cfaf16853042",
      "dex_id": "makerdao",
      "dex_name": "MakerDAO",
      "volume_usd_24h": 1657645861.93,
      "volume_usd_7d": 9412300120.5,
      "liquidity_usd": 41250000.0,
      "transactions_24h": 4383,
      "price_usd": 1.0,
      "created_at": "2024-07-11T13:48:47Z",
      "tokens": []
    }
  ],
  "has_next_page": true,
  "next_cursor": "eyJvZmZzZXQiOjV9",
  "query": {}
}
```

<Note>
  Response field names: pool address is `id`, transaction count is `transactions_24h`, DEX is `dex_id` (slug) plus `dex_name` (label). Results are in a `results` array, and you page with `next_cursor` rather than page numbers.
</Note>

***

## Example 2: Recently created pools with activity

Find pools created in the last 7 days that have at least 50 transactions:

<CodeGroup>
  ```bash bash theme={null}
  # Calculate UNIX timestamp for 7 days ago
  SEVEN_DAYS_AGO=$(python3 -c "import time; print(int(time.time()) - 7*86400)")

  curl "https://api.dexpaprika.com/networks/base/pools/search?created_after=$SEVEN_DAYS_AGO&txns_24h_min=50&order_by=created_at&sort=desc&limit=10"
  ```

  ```python python theme={null}
  import requests
  import time

  seven_days_ago = int(time.time()) - 7 * 86400

  response = requests.get("https://api.dexpaprika.com/networks/base/pools/search", params={
      "created_after": seven_days_ago,
      "txns_24h_min": 50,
      "order_by": "created_at",
      "sort": "desc",
      "limit": 10
  })

  data = response.json()

  for pool in data["results"]:
      print(f"  Created: {pool['created_at']} | DEX: {pool['dex_name']} | Txns: {pool['transactions_24h']} | Vol: ${pool['volume_usd_24h']:,.0f}")
  ```
</CodeGroup>

***

## Example 3: Paginating through all results

Page with the cursor returned in each response:

```python theme={null}
import requests

all_pools = []
cursor = None

while True:
    params = {
        "volume_usd_24h_min": 10000,
        "txns_24h_min": 20,
        "order_by": "volume_usd_24h",
        "sort": "desc",
        "limit": 100
    }
    if cursor:
        params["cursor"] = cursor

    data = requests.get(
        "https://api.dexpaprika.com/networks/solana/pools/search", params=params
    ).json()

    all_pools.extend(data["results"])
    print(f"Collected {len(all_pools)} pools so far")

    if not data["has_next_page"]:
        break
    cursor = data["next_cursor"]

print(f"Total pools matching criteria: {len(all_pools)}")
```

***

## Example 4: Combining with pool details

Search returns summary data. To get full pool details (token pair info, reserves, fees), make a follow-up request:

```python theme={null}
import requests

# Step 1: Find interesting pools
response = requests.get("https://api.dexpaprika.com/networks/ethereum/pools/search", params={
    "volume_usd_24h_min": 100000,
    "txns_24h_min": 500,
    "limit": 5
})

pools = response.json()["results"]

# Step 2: Get full details for each pool
for pool in pools:
    details = requests.get(
        f"https://api.dexpaprika.com/networks/{pool['chain']}/pools/{pool['id']}"
    ).json()

    tokens = details.get("tokens", [])
    pair = "/".join(t["symbol"] for t in tokens) if tokens else "Unknown"
    print(f"{pair} on {pool['dex_name']} -- Vol: ${pool['volume_usd_24h']:,.0f}")
```

***

## Tips

* **Start broad, then narrow:** Begin with just `volume_usd_24h_min` to see what matches, then add more filters.
* **Use `created_after` for new token discovery:** Combine with `txns_24h_min` to find new pools that actually have trading activity.
* **Different networks, different thresholds:** A \$10k volume pool on Ethereum is tiny; on a smaller chain it might be significant. Adjust thresholds per network.
* **Search across networks:** Use `GET /pools/search?chains=ethereum,base,solana` to screen multiple networks in one call.

***

## Next steps

<CardGroup cols={2}>
  <Card title="Find New Pools" icon="plus-circle" href="/tutorials/find-new-pools">
    More techniques for discovering new pools using the search endpoint
  </Card>

  <Card title="Pool Details" icon="water" href="/api-reference/pools/get-a-pool-on-a-network">
    Get full details for any pool including token pairs and reserves
  </Card>

  <Card title="Common Patterns" icon="book" href="/knowledge-base/common-patterns">
    Standard API workflows including search, pricing, and historical data
  </Card>

  <Card title="Pool Details API" icon="bolt" href="/api-reference/pools/get-a-pool-on-a-network">
    Full pool details endpoint documentation
  </Card>
</CardGroup>

### FAQs

<AccordionGroup>
  <Accordion title="What happened to the old /pools/filter endpoint?">
    It was removed and now returns `410 Gone`, along with `/networks/{network}/pools` and the global `/pools`. Use `/networks/{network}/pools/search` (single network) or `/pools/search` (multiple networks) instead.
  </Accordion>

  <Accordion title="Can I filter pools across multiple networks at once?">
    Yes. Use the global `GET /pools/search` with a `chains` parameter, for example `chains=ethereum,base`. The per-network `GET /networks/{network}/pools/search` covers a single network.
  </Accordion>

  <Accordion title="How does pagination work?">
    Set `limit` and read `has_next_page` and `next_cursor` from the response. Pass `next_cursor` back as `cursor` to fetch the next page. There are no page numbers.
  </Accordion>
</AccordionGroup>

<script type="application/ld+json">
  {JSON.stringify({
      "@context": "https://schema.org",
      "@type": "FAQPage",
      "mainEntity": [
        {"@type": "Question","name": "What happened to the old DexPaprika /pools/filter endpoint?","acceptedAnswer": {"@type": "Answer","text": "It was removed and returns 410 Gone, along with /networks/{network}/pools and /pools. Use /networks/{network}/pools/search or /pools/search instead."}},
        {"@type": "Question","name": "Can I filter pools across multiple networks?","acceptedAnswer": {"@type": "Answer","text": "Yes. Use the global /pools/search with a chains parameter. The per-network /networks/{network}/pools/search covers a single network."}},
        {"@type": "Question","name": "How does pool search pagination work?","acceptedAnswer": {"@type": "Answer","text": "Set limit and read has_next_page and next_cursor. Pass next_cursor back as cursor for the next page. There are no page numbers."}}
      ]
    })}
</script>