# GeckoTerminal DEX Pool Market Data (`automation-lab/geckoterminal-dex-pool-market-data`) Actor

Fetch current GeckoTerminal DEX pool IDs, prices, 24-hour volume and liquidity by network for repeat market comparisons.

- **URL**: https://apify.com/automation-lab/geckoterminal-dex-pool-market-data.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## GeckoTerminal DEX Pool Market Data

Export current geckoterminal dex pools as timestamped records: network and pool IDs, token USD prices, 24-hour trading volume, and USD liquidity. Schedule runs to compare pool conditions over time. This Actor reads GeckoTerminal's public JSON API directly, without a browser or a proxy.

### Who is it for?

These snapshots serve teams that repeatedly measure DEX pool conditions.

#### Typical analysis

Compare volume-to-liquidity ratios for a known list of pools without treating them as trading recommendations.

### Who uses these pool snapshots?

DEX analysts can compare liquidity and turnover across supported networks. Token research teams can revisit a known pool address; data engineers can append run datasets to a historical warehouse. Each run captures a snapshot, not a built-in historical time series.

### Why use this Actor?

Instead of parsing visual pool cards, the Actor uses structured source records and emits consistent typed fields. Input supports network discovery and exact pool addresses; both obey a global result limit. A failed API request raises an error rather than silently returning an empty successful run.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `poolId`, `network`, `address`, `name` | GeckoTerminal pool identity and display label |
| `baseTokenPriceUsd`, `quoteTokenPriceUsd` | Current displayed token prices in USD |
| `volume24hUsd`, `liquidityUsd` | 24-hour USD turnover and current USD reserve |
| `priceChange24hPercent` | Source 24-hour base price change |
| `poolCreatedAt`, `sourceUrl`, `scrapedAt` | Source creation time, pool link, and run snapshot time |

Missing source numeric values become `null`, not zero. Prices are converted from the source's decimal strings to numbers.

### Getting started

1. Leave `networks` as `["eth"]` for an Ethereum sample or enter GeckoTerminal network IDs.
2. Leave `poolAddresses` empty to list pools, or supply one or more known addresses to inspect those same addresses on every selected network.
3. Set `maxItems` to cap the combined output. Start with 3 for a quick test.
4. Run the Actor and inspect the default dataset overview. Schedule repeated runs if you need comparison snapshots.

### Input parameters

- `networks`: 1–10 GeckoTerminal network IDs; default `eth`. Wrong or unsupported IDs fail with the source's response.
- `poolAddresses`: optional list of up to 100 addresses; when present, replaces list pagination. A pool address must exist on *each* selected network.
- `maxItems`: 1–200 distinct results across all networks, default 20. Discovery scans at most ten pages per network (20 pools per page).

Example network discovery: `{"networks":["eth"],"maxItems":3}`. To revisit one pool: `{"networks":["eth"],"poolAddresses":["0xe0554a476a092703abdb3ef35c80e0d76d32939f"],"maxItems":1}`.

### Output example

A local Ethereum listing returned a pool record in this form (market values change):

```json
{"poolId":"eth_0xe0554a476a092703abdb3ef35c80e0d76d32939f","network":"eth","address":"0xe0554a476a092703abdb3ef35c80e0d76d32939f","name":"USDC / WETH 0.01%","baseTokenPriceUsd":1.00027320517615,"quoteTokenPriceUsd":2723.77,"volume24hUsd":80568434.8520867,"liquidityUsd":6479697.3386,"priceChange24hPercent":0.084,"poolCreatedAt":"2021-12-30T20:32:10Z","sourceUrl":"https://www.geckoterminal.com/eth/pools/0xe0554a476a092703abdb3ef35c80e0d76d32939f","scrapedAt":"2026-09-29T14:04:49.455Z"}
```

### How much does it cost to export GeckoTerminal pool snapshots?

The Actor charges $0.0025 for one `start` event per run and one `item` event per saved pool. At the BRONZE spend tier the item price is $0.00216: a 1-pool run costs about $0.00466, a 10-pool run about $0.02410, and a 100-pool run about $0.21850 in Actor charges. Item rates by Apify spend tier are FREE $0.002484, BRONZE $0.00216, SILVER $0.0016848, and GOLD/PLATINUM/DIAMOND $0.001296. These are estimates, not guaranteed invoices; Apify billing rules and adjustments may apply. Only accepted dataset rows incur item charges; a source with fewer listed pools yields fewer charged rows. Check the live pricing panel for the active tier.

### Integrations and repeat comparisons

Run on a schedule, then export the default dataset as JSON or CSV. Append records keyed by `poolId` and `scrapedAt` into a warehouse or spreadsheet. Compute changes in price or liquidity between snapshots downstream; this Actor does not send alerts or maintain history itself.

### API access with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~geckoterminal-dex-pool-market-data/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' -d '{"networks":["eth"],"maxItems":3}'
```

Use the returned run's `defaultDatasetId` with the Apify datasets API to fetch results.

### API access with JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/geckoterminal-dex-pool-market-data').call({ networks: ['eth'], maxItems: 3 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API access with Python

```python
from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/geckoterminal-dex-pool-market-data').call(run_input={'networks': ['eth'], 'maxItems': 3})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP for agents

Claude Code can add the Actor-specific Apify MCP tools:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/geckoterminal-dex-pool-market-data"
```

Claude Desktop, Cursor, and VS Code can each use this HTTP MCP server configuration (in their respective MCP settings):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/geckoterminal-dex-pool-market-data"}}}
```

Example prompts: “Fetch three Ethereum pools and compare their 24-hour volume with USD liquidity.” “Revisit this pool address and show its current liquidity.” Never expose your API token in a shared prompt.

### Privacy, retention, and AI

The Actor does not use AI, cookies, user accounts, or paid third-party APIs. It sends selected public network IDs and pool addresses to GeckoTerminal's public API; GeckoTerminal is the source recipient. The default Apify dataset retains only market records and capture timestamps, subject to your Apify account's storage retention and deletion controls. It does not log credentials or collect personal profiles. Delete runs and datasets from Apify Console when no longer needed.

### Limits and data freshness

The network pool list is a source-selected listing, not a complete index of all pools. At most ten pages per network are scanned. GeckoTerminal controls data freshness, network coverage, and API rate limits. The Actor retries transient HTTP 429/5xx twice; persistent errors fail the run. It does not scrape gated content, generate token-level histories, or guarantee every DEX pool is present.

### Legality and responsible use

Use public market information responsibly. Check GeckoTerminal's API policies and your jurisdiction's rules before commercial redistribution. Market snapshots are not financial advice; verify decisions against primary market sources.

### Troubleshooting

**Why did a run fail with HTTP 404?** Verify the network ID and that every supplied address exists on that network. An address on another chain is not interchangeable.

**Why are fewer records returned than `maxItems`?** The source may return fewer listed pools, the ten-page cap may be reached, or duplicates may be skipped. Inspect the run log and requested network.

**Why did the run fail with HTTP 429?** GeckoTerminal rate-limited the public API. Wait and retry at a lower schedule frequency; avoid overlapping high-volume runs.

### Related automation-lab Actors

For pair-level data from another source, see [DexScreener Token Pair Market Data](https://apify.com/automation-lab/dexscreener-token-pair-market-data). Its source and record coverage differ from GeckoTerminal. For broader cryptocurrency metadata, see [CoinPaprika Crypto Market Data Exporter](https://apify.com/automation-lab/coinpaprika-crypto-market-data).

### FAQ

**Can I collect historical prices?** Repeated scheduled runs create your own time-stamped snapshots. This Actor does not backfill earlier dates.

**Does it require a proxy or wallet?** No, the public API route is accessed directly and requires neither a wallet nor a proxy.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/geckoterminal-dex-pool-market-data/changelog.md

# Actor input Schema

## `networks` (type: `array`):

GeckoTerminal network IDs (for example eth or bsc). Up to 10; all selected networks share the same filters.

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

When supplied, fetch these pools on every selected network instead of listing network pools. Up to 100 addresses.

## `maxItems` (type: `integer`):

Maximum number of distinct pool snapshots returned across all networks. Listing scans up to ten pages per network.

## Actor input object example

```json
{
  "networks": [
    "eth"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset overview of saved GeckoTerminal pool snapshots

# 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 = {
    "networks": [
        "eth"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/geckoterminal-dex-pool-market-data").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 = {
    "networks": ["eth"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/geckoterminal-dex-pool-market-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "networks": [
    "eth"
  ],
  "maxItems": 20
}' |
apify call automation-lab/geckoterminal-dex-pool-market-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/geckoterminal-dex-pool-market-data"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3HvaM38nQuSdJGxwv/builds/GyniNgLgn5koFxBL5/openapi.json