# DEX Pool Prices: History, Liquidity and Trade Flow (`scrapemint/dex-pool-price-tracker`) Actor

Track on-chain liquidity pools across 100+ networks. Get price, liquidity, 24h volume, turnover and unique buyer/seller flow per pool, plus OHLCV candle history for any pool you name. Keyless, no browser, no proxy. Pay per row.

- **URL**: https://apify.com/scrapemint/dex-pool-price-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## DEX Pool Prices: History, Liquidity and Trade Flow

Track on-chain liquidity pools across **100+ networks** through GeckoTerminal's public API. Keyless, no browser, no proxy.

Two things here that a plain DEX screener does not give you:

- **OHLCV candle history per pool.** Open, high, low, close and volume at minute, hour or day resolution, so a pool has a price *history* and not just a current price.
- **Unique buyers and sellers**, not only buy and sell counts. Raw transaction counts are easy to inflate with wash trades; distinct participants are harder to fake, so the flow read is stated on those.

### Modes

| Mode | What it does | Requests used |
|---|---|---|
| `pools` | Current price, liquidity, volume, turnover and trade flow for a network's trending or newly created pools | **1** (returns 20 pools) |
| `history` | OHLCV candles for pool addresses you name | **1 per pool** (max 5) |
| `networks` | Every supported network id, so you can look up the right one | **1** (returns 100) |

### Read this before scaling up: the venue has a hard request quota

GeckoTerminal's free tier throttles shared datacenter IPs aggressively. Measured from an Apify datacenter IP by sweeping the gap between requests:

```
gap  1000ms -> 200,200,200,200,200,429,429,429
gap  3000ms -> 200,200,200,200,200,429,429,200
gap  6000ms -> 200,200,200,200,200,429,429,429
gap 10000ms -> 200,200,200,200,200,200,429,200
```

**Five requests go through at any gap, and a 10s gap buys exactly one more.** This is a quota of roughly five requests per window, not a rate you can outrun by waiting longer, and it appears to be shared with whatever else is using that datacenter IP.

Recovery was measured too: after a deliberate 12-request burst that drew 7 refusals, the endpoint served normally again **45 seconds later**. The actor's backoff (15s, 30s, 45s) is sized against that.

What this means in practice:

- **`pools` and `networks` modes are unaffected.** They each cost one request and return 20 and 100 rows.
- **`history` mode is the expensive one.** It costs one request per pool, so it is capped at 5 pools per run and retries with growing backoff (15s, 30s, 45s) when throttled.
- A run that gets throttled emits a **free note row** saying results may be partial. It never returns silently empty and never charges you for a row it did not get.

### What you get

**`pools` mode**, one row per pool:

| Field | Meaning |
|---|---|
| `poolName` / `poolAddress` / `dex` | Which pool, on which DEX. Feed `poolAddress` into history mode. |
| `priceUsd` / `quotePriceUsd` | Base and quote token price |
| `priceChangePct5m` / `1h` / `24h` | Momentum across three windows |
| `liquidityUsd` | Reserves held in the pool |
| `volume24hUsd` | Traded in the last 24h |
| `turnoverRatio24h` | Volume divided by liquidity. **A high reading on thin liquidity is a pool being churned**, and it is the number that separates real depth from noise. |
| `buys24h` / `sells24h` | Transaction counts |
| `uniqueBuyers24h` / `uniqueSellers24h` | Distinct wallets on each side |
| `buySellRatio24h` / `uniqueBuyerSellerRatio24h` | Flow imbalance, by transactions and by participants |
| `flowRead` | Plain-language read of the participant imbalance |
| `fdvUsd` / `marketCapUsd` / `marketCapReported` | Valuation. See the note below on market cap. |
| `lockedLiquidityPct` / `poolFeePercentage` / `poolCreatedAt` | Pool characteristics |

**`history` mode**, one row per candle: `timeframe`, `aggregate`, `timestamp`, `openedAt`, `open`, `high`, `low`, `close`, `volumeUsd`.

### Source quirks handled for you

- **Every numeric field arrives as a string** (`"0.00396995436661614"`). All are converted, and an unreported figure stays `null` rather than becoming a real `0`.
- **Market cap is often not reported.** The venue only knows it when circulating supply is known, and signals "unknown" as both `null` *and* the string `"0.0"`. Since a live pool cannot have a zero market cap, both map to `null` and `marketCapReported` tells you which rows have a real figure. **Use `fdvUsd` when it does not.** In a sample of 5 trending pools, 1 had no market cap at all.
- **`week` and `month` candles do not exist.** The venue answers HTTP 400 rather than falling back, so only minute, hour and day are offered.
- **Candle timestamps are in seconds**, not milliseconds. `openedAt` gives you the ISO string.
- `lockedLiquidityPct` is frequently `null` and is passed through as such.

### Input

| Field | Description |
|---|---|
| `mode` | `pools`, `history` or `networks` |
| `network` | Chain id, e.g. `eth`, `bsc`, `base`, `solana`, `polygon_pos`. Run `networks` mode to list them. |
| `poolList` | `trending` or `new` (pools mode) |
| `poolAddresses` | Pools to pull candles for (history mode, max 5) |
| `timeframe` / `aggregate` / `candleLimit` | Candle size and count (history mode) |
| `minLiquidityUsd` / `minVolume24hUsd` | Filter out thin pools (pools mode) |
| `requestGapMs` | Spacing between requests. Does not defeat the quota, see above. |
| `maxRows` | Cap on rows returned, controls cost |

### Pricing

Pay per event: **$0.004 per row** pushed, whether a pool, a candle or a network. The first 2 rows of every run are free. Notes and rate-limit warnings are always free.

### Notes & limits

- Prices are live snapshots and on-chain pools move continuously.
- A pool's price is the price *in that pool*. Thin pools can quote far from the wider market, which is exactly what `liquidityUsd` and `turnoverRatio24h` are there to expose.
- New pools carry the most risk. High turnover on low liquidity with lopsided flow is a common shape for a token being churned, and this actor reports the inputs rather than pretending to judge them.

# Actor input Schema

## `mode` (type: `string`):

pools = current price, liquidity and trade flow for a network's pools. history = OHLCV candles for pool addresses you name. networks = list every supported network id.

## `network` (type: `string`):

Which chain to read, e.g. eth, bsc, polygon\_pos, base, arbitrum, solana. Run networks mode once to see every valid id.

## `poolList` (type: `string`):

trending = pools with the most current activity. new = recently created pools.

## `poolAddresses` (type: `array`):

Pool contract addresses to pull candles for. Run pools mode first and copy the poolAddress values. Capped at 5 per run: each pool costs one request and the venue allows only about five before it throttles.

## `timeframe` (type: `string`):

Candle size. The venue rejects any other value, so week and month are not available.

## `aggregate` (type: `integer`):

Group candles, e.g. timeframe=minute with aggregate=15 gives 15-minute candles.

## `candleLimit` (type: `integer`):

How many candles to request per pool.

## `minLiquidityUsd` (type: `integer`):

Skip pools holding less than this in reserves.

## `minVolume24hUsd` (type: `integer`):

Skip pools trading less than this in the last 24 hours.

## `requestGapMs` (type: `integer`):

How long to wait between requests. Note the venue enforces a quota of about five requests per window, so raising this does not buy more requests (measured: the 6th fails at a 1s, 3s and 6s gap alike). Pools and networks modes only make one request and are unaffected.

## `maxRows` (type: `integer`):

Cap on rows returned. Controls total cost.

## Actor input object example

```json
{
  "mode": "pools",
  "network": "eth",
  "poolList": "trending",
  "poolAddresses": [],
  "timeframe": "hour",
  "aggregate": 1,
  "candleLimit": 100,
  "minLiquidityUsd": 0,
  "minVolume24hUsd": 0,
  "requestGapMs": 3000,
  "maxRows": 100
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "pools",
    "network": "eth",
    "poolList": "trending",
    "timeframe": "hour"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/dex-pool-price-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "pools",
    "network": "eth",
    "poolList": "trending",
    "timeframe": "hour",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/dex-pool-price-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "pools",
  "network": "eth",
  "poolList": "trending",
  "timeframe": "hour"
}' |
apify call scrapemint/dex-pool-price-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/dex-pool-price-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oBKdGfL3Msl63w64X/builds/9f7BpBDqANXVlTQLI/openapi.json