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

***

## 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 |
| `price_change_percentage_48h_min` / `_max` | number | 48h price change, percent |
| `price_change_percentage_6h_min` / `_max` | number | 6h price change, percent |
| `price_change_percentage_1h_min` / `_max` | number | 1h price change, percent |
| `price_change_percentage_5m_min` / `_max` | number | 5m price change, percent |
| `created_after` / `created_before` | string | Creation-time window: unix seconds or relative (`-24h`, `-7d`), RFC3339 or `YYYY-MM-DD` |
| `dex_name` | string | Restrict to a single DEX |
| `token_address` | string | Restrict to pools that contain this token (per-network search only) |
| `order_by` | string | `volume_usd_24h`, `volume_usd_7d`, `volume_usd_30d`, `liquidity_usd`, `txns_24h`, `created_at`, `price_usd`, `price_change_percentage_48h`, `price_change_percentage_24h`, `price_change_percentage_6h`, `price_change_percentage_1h`, `price_change_percentage_5m` |
| `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.

> [!WARNING]
>
> The `token_address` filter works on the per-network `GET /networks/{network}/pools/search` only. The cross-network `GET /pools/search` accepts the parameter but silently ignores it, so a token filter without a network returns unfiltered results.

### Price change windows

Pool search covers five windows: 48h, 24h, 6h, 1h and 5m. Each one is both a filter pair and a sort field, so you can screen over the horizon you actually trade on instead of reading a 24h number and guessing what happened in the last few minutes.

A percentage filter is a plain numeric bound, so the minus sign carries the direction. `price_change_percentage_1h_max=-20` means "down by at least 20 percent in the last hour", and `price_change_percentage_1h_min=50` means "up by at least 50 percent". There is no separate direction parameter.

```bash theme={null}
# Ethereum pools that dropped 20 percent or more in the last hour
curl "https://api.dexpaprika.com/networks/ethereum/pools/search?price_change_percentage_1h_max=-20&order_by=price_change_percentage_1h&sort=asc&limit=5"
```

> [!WARNING]
>
> Verify a percentage filter against an unfiltered baseline the first time you use one. An unknown parameter **name** is dropped silently rather than rejected, so a typo like `price_change_1h_max` still returns `200` with a full, unfiltered page of results. Compare the `price_change_percentage_1h` values you get back against a plain `?limit=5` call: unfiltered rows sit near zero, filtered rows respect the bound.

> [!WARNING]
>
> Every window but 24h is pool-only. `GET /networks/{network}/tokens/search` rejects `order_by=price_change_percentage_48h`, `price_change_percentage_6h`, `price_change_percentage_1h` and `price_change_percentage_5m` with a `400`, and token rows carry none of those four fields, with or without `detailed=true`. The 24h window works on both: token search sorts by `price_change_percentage_24h` and filters on `price_change_percentage_24h_min` / `_max`.
>
> The pool-only **filters** behave worse than the sort fields on the token side. `price_change_percentage_6h_min` is not rejected there, it is dropped, so token search answers `200` with the same unfiltered page you would get without it.

***

## Example 1: High-volume pools on Ethereum

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

```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}`);
});
```

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

***

## Example 2: Recently created pools with activity

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

```bash bash theme={null}
# -7d means "7 days before now"; no timestamp arithmetic needed
curl "https://api.dexpaprika.com/networks/base/pools/search?created_after=-7d&txns_24h_min=50&order_by=created_at&sort=desc&limit=10"
```

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

response = requests.get("https://api.dexpaprika.com/networks/base/pools/search", params={
    "created_after": "-7d",
    "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}")
```

***

## 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.
* **Filter by token:** Pass `token_address` on the per-network search to list only pools containing that token. This replaces the removed `/networks/{network}/tokens/{token_address}/pools` endpoint. The [token pools tutorial](https://docs.dexpaprika.com/tutorials/token-pools.md) walks through it, paging and migration included.

***

## Next steps

> **[Find New Pools](https://docs.dexpaprika.com/tutorials/find-new-pools.md)**
>
> More techniques for discovering new pools using the search endpoint

> **[Pool Details](https://docs.dexpaprika.com/api-reference/pools/get-a-pool-on-a-network.md)**
>
> Get full details for any pool including token pairs and reserves

> **[Common Patterns](https://docs.dexpaprika.com/knowledge-base/common-patterns.md)**
>
> Standard API workflows including search, pricing, and historical data

> **[Pool Details API](https://docs.dexpaprika.com/api-reference/pools/get-a-pool-on-a-network.md)**
>
> Full pool details endpoint documentation

### FAQs

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

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

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

> **How do I find pools for a specific token?**
>
> Pass `token_address` on the per-network search: `GET /networks/{network}/pools/search?token_address={address}`. This replaces the removed `/networks/{network}/tokens/{token_address}/pools` endpoint, which now returns `410 Gone`. The filter is per-network only; the cross-network `/pools/search` silently ignores it. One token per query: repeating the parameter does not act as a pair filter (the API uses only one of the values, not guaranteed by order), and the old second-token pair filter has no equivalent.
>
> The [token pools tutorial](https://docs.dexpaprika.com/tutorials/token-pools.md) covers this end to end: the call, the response fields, paging, and the migration from the removed endpoint.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.