# GeckoTerminal DEX Pools Scraper (`logiover/geckoterminal-dex-pools-scraper`) Actor

Scrape live DEX liquidity pools from GeckoTerminal across 100+ blockchains — price, FDV, market cap, liquidity, 1h/6h/24h volume, price change and transaction counts. Thousands of pools per run. Schedule it for a continuously fresh on-chain feed.

- **URL**: https://apify.com/logiover/geckoterminal-dex-pools-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 🦎 GeckoTerminal DEX Pools Scraper — Scrape On-Chain DEX Liquidity & Price Data

![GeckoTerminal DEX Pools Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-N30W0bnxWcpNFTkzj-FN6xCf6m1x-GeckoTerminal.png)

**Bulk export of live DEX liquidity pools from [GeckoTerminal](https://www.geckoterminal.com) across 100+ blockchains — Ethereum, Solana, BSC, Base, Arbitrum, Polygon, Avalanche, Optimism, Sui, TON, Aptos and many more — in one run, with one flat dataset.** Token prices, FDV, market cap, pool reserve (liquidity), 1h / 6h / 24h volume, 1h / 24h price change and 24h transaction counts per pool — straight from the official GeckoTerminal API.

Built for **DeFi traders, DEX arbitrage bots, on-chain analytics platforms, multichain liquidity dashboards, tokenomics research desks, new-token hunters, memecoin scanners, MEV searchers, market-making firms, indexer pipelines and DeFi data products** that need the full GeckoTerminal pool feed at scale — without writing per-chain pagination, retry, sort and filter logic by hand.

🟢 No login. No API key required. No headless browser. Pure official GeckoTerminal REST API.

---

### What this scraper does

GeckoTerminal is CoinGecko's on-chain DEX data layer. It indexes every major liquidity pool across 100+ EVM, Solana, Move and other chains — Uniswap V2 / V3 / V4, PancakeSwap, SushiSwap, Curve, Balancer, Aerodrome, Velodrome, Camelot, QuickSwap, Trader Joe, SpookySwap, Raydium, Orca, Meteora, Lifinity, Pump.fun, Cetus, Bluefin, Hyperliquid Spot and many more.

Pulling this data well at scale requires:

- Iterating per network (each chain is a separate paginated endpoint)
- Paginating through up to 200 pools per network in 20-pool pages
- Backing off correctly on HTTP 429
- Filtering out dead and low-liquidity pools
- Flattening deeply nested JSON-API responses into spreadsheet rows
- Streaming output to disk before the run ends

This **GeckoTerminal DEX pools scraper** does all of that for you. Pick your networks, set a minimum 24h volume to skip dead pools, and get back a flat, sorted, filtered dataset of every active DEX pool — ready for Excel, Postgres, your trading bot or your dashboard.

---

### ✨ Key features

| Feature | What it gives you |
|---|---|
| 🦎 **Official GeckoTerminal API** | Reliable, fully structured on-chain DEX data — no blocking, no headless browser, no scraping headaches |
| 🌐 **100+ networks** | Ethereum, Solana, BSC, Base, Arbitrum, Polygon, Avalanche, Optimism, Fantom, Cronos, Sui, TON, Aptos, Sei, Tron, PulseChain, Hyperliquid EVM, Berachain, Monad, Sonic, Linea, Mantle, Scroll, zkSync, Blast, Mode and many more |
| 📊 **17 rich fields per pool** | Pool address, network, name, base/quote token price (USD), FDV, market cap, USD reserve, 1h/6h/24h volume, 1h/24h price change %, 24h txn count, pool creation date, GeckoTerminal URL |
| 🧹 **Volume filter** | Drop dead and low-liquidity pools with a minimum 24h volume threshold |
| 📈 **Scale** | Up to 200 pools per network × as many networks as you want — thousands of pools per run |
| 🔗 **Direct pool links** | Every record includes the GeckoTerminal pool page URL and the on-chain pool contract address |
| ⚡ **Rate-limit safe** | Built-in throttling and exponential backoff respect GeckoTerminal's public API limits |
| ⏰ **Schedule-ready** | Designed for hourly / 15-min / 5-min recurring runs |
| 📤 **Flat structured rows** | 17 columns, no nested JSON, no `data.attributes.relationships.included` wrangling |
| 💾 **JSON, CSV, Excel exports** | Direct Apify Dataset → any format |
| 🔓 **Public API only** | No auth, no proxy, no Cloudflare bypass |
| 🆕 **New-pool discovery** | Use the `poolCreatedAt` field to surface freshly-launched pools across chains |

---

### 🎯 Built for these use cases

#### 1. DEX traders and arbitrageurs
Pull top 200 pools per chain on every chain that interests you, sort by 24h volume + reserve, and surface cross-DEX or cross-chain arbitrage opportunities. Compare price for the same token across Solana DEXes (Raydium vs. Orca vs. Meteora) or across EVMs (Uniswap on Ethereum vs. Base vs. Arbitrum).

#### 2. New-token hunters and memecoin scanners
Schedule the scraper every 5 minutes against Solana, Base and BSC. Filter on `poolCreatedAt` to surface pools created in the last hour. Combine with a `minVolumeUsd` floor to filter out rugs and dead launches.

#### 3. Multichain liquidity dashboards
Power a "where is the liquidity on $TOKEN?" dashboard. Aggregate `reserveInUsd` per network, per DEX, per token to show users where their token is most liquid.

#### 4. MEV searchers and market makers
Every pool row includes `poolAddress` so you can target on-chain transactions directly. Filter to fresh pools with strong 1h volume to identify market-making opportunities.

#### 5. Tokenomics and pricing research
Combine `baseTokenPriceUsd`, `fdvUsd` and `marketCapUsd` with `reserveInUsd` to evaluate fundamentals — how much liquidity exists relative to FDV? Is the pool deep enough to support claimed market cap?

#### 6. On-chain analytics and indexer pipelines
Use this scraper as the upstream price feed for your own indexer. Refresh hourly to keep your on-chain analytics product fresh without running your own GeckoTerminal-clone infrastructure.

#### 7. DeFi research and TVL studies
Daily snapshots build a longitudinal record of DEX pool TVL, volume and momentum across the multichain ecosystem — ideal for cross-sectional DeFi research.

#### 8. Portfolio dashboards and wallet apps
Power live USD-denominated portfolio valuations for tokens that don't live on CEXes. GeckoTerminal is the canonical on-chain price source for long-tail tokens.

---

### 📥 Inputs

| Field | Type | Required | Description |
|---|---|---|---|
| `networks` | string[] | ✅ Yes | Blockchain network slugs to scrape. Examples: `eth`, `solana`, `bsc`, `base`, `arbitrum`, `polygon_pos`, `avax`, `optimism`, `fantom`, `cronos`, `pulsechain`, `sui-network`, `ton`, `aptos`, `sei-network`, `tron`, `hyperliquid`, `berachain`, `monad`, `sonic`, `linea`, `mantle`, `scroll`, `zksync`, `blast`, `mode`. |
| `maxPoolsPerNetwork` | int | No | Maximum pools to fetch per network (up to 200). `0` = all available. |
| `minVolumeUsd` | int | No | Skip pools with 24h USD volume below this — filters out dead and low-liquidity pools. Default `0`. |

#### Example inputs

**Top pools across the biggest 6 chains, no volume filter:**
```json
{
  "networks": ["eth", "solana", "bsc", "base", "arbitrum", "polygon_pos"],
  "maxPoolsPerNetwork": 0,
  "minVolumeUsd": 0
}
````

**Solana memecoin scan — high volume, every pool:**

```json
{
  "networks": ["solana"],
  "maxPoolsPerNetwork": 200,
  "minVolumeUsd": 10000
}
```

**EVM L2 liquidity sweep — Base, Arbitrum, Optimism, Linea, Mantle, Scroll, zkSync, Blast:**

```json
{
  "networks": ["base", "arbitrum", "optimism", "linea", "mantle", "scroll", "zksync", "blast"],
  "maxPoolsPerNetwork": 100,
  "minVolumeUsd": 5000
}
```

***

### 📤 Output

Each DEX pool is saved as one structured row in the Apify Dataset. Export to JSON, CSV, Excel (XLSX), HTML or JSONL.

#### Sample row

```json
{
  "poolAddress": "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
  "network": "eth",
  "name": "USDC / WETH 0.05%",
  "baseTokenPriceUsd": 1.0001,
  "quoteTokenPriceUsd": 3214.55,
  "fdvUsd": 33812091123,
  "marketCapUsd": 33812091123,
  "reserveInUsd": 412781234,
  "volumeUsd24h": 198412377,
  "volumeUsd6h": 47812341,
  "volumeUsd1h": 8923441,
  "priceChangePct24h": 0.02,
  "priceChangePct1h": -0.01,
  "txns24h": 18217,
  "poolCreatedAt": "2021-05-05T21:42:14.000Z",
  "url": "https://www.geckoterminal.com/eth/pools/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
  "scrapedAt": "2026-05-16T12:30:11.000Z"
}
```

#### Full field reference (17 fields)

| Field | Type | Meaning |
|---|---|---|
| `poolAddress` | string | On-chain pool / LP contract address |
| `network` | string | GeckoTerminal network slug (`eth`, `solana`, `bsc`, `base`, `arbitrum`, etc.) |
| `name` | string | Human-readable pool name, usually `BASE / QUOTE` plus DEX-specific tag |
| `baseTokenPriceUsd` | number | Base token price in USD |
| `quoteTokenPriceUsd` | number | Quote token price in USD |
| `fdvUsd` | number | Fully diluted valuation of the base token in USD |
| `marketCapUsd` | number | Market capitalization of the base token in USD |
| `reserveInUsd` | number | Total pool liquidity / reserve in USD (both sides combined) |
| `volumeUsd24h` | number | Trading volume in the last 24 hours, USD |
| `volumeUsd6h` | number | Trading volume in the last 6 hours, USD |
| `volumeUsd1h` | number | Trading volume in the last 1 hour, USD |
| `priceChangePct24h` | number | Base token price change in the last 24 hours, % |
| `priceChangePct1h` | number | Base token price change in the last 1 hour, % |
| `txns24h` | number | Total swap transaction count in the last 24 hours |
| `poolCreatedAt` | string | ISO 8601 timestamp of pool creation (use for new-pool discovery) |
| `url` | string | GeckoTerminal pool page URL |
| `scrapedAt` | string | ISO 8601 timestamp when this row was saved |

***

### ⚙️ How it works

1. **Reads input** — list of network slugs, per-network pool cap, minimum 24h volume.
2. **Iterates each network** — for every network slug, hits the `networks/{network}/pools` endpoint.
3. **Paginates** — 20 pools per page, up to 10 pages per network (200 pools per network max — GeckoTerminal API limit).
4. **Applies the volume filter** in-stream — pools below `minVolumeUsd` are dropped before being saved.
5. **Backs off on HTTP 429** with exponential delays.
6. **Flattens** JSON-API responses (`data.attributes`) into 17-field rows.
7. **Streams** rows into the Apify Dataset.

The scraper uses ONLY GeckoTerminal's officially-supported public REST API (`api.geckoterminal.com/api/v2`). No HTML scraping, no headless browser, no proxy, no anti-bot bypass. Endpoints are documented at [geckoterminal.com/dex-api](https://www.geckoterminal.com/dex-api).

***

### ⚡ Performance

| Workload | Time | API calls |
|---|---|---|
| 1 network, 20 pools | ~2 seconds | 1 |
| 1 network, 200 pools | ~10 seconds | 10 |
| 6 networks, 200 pools each | ~45 seconds | 60 |
| 20 networks, 200 pools each | ~3 minutes | 200 |
| 50 networks, 100 pools each | ~4 minutes | 250 |

GeckoTerminal's public API allows ~30 requests/minute. The scraper stays well within that with sensible pacing.

***

### 💰 Cost model

This actor uses **Pay-Per-Result** pricing — you pay only for the pool rows actually saved (after the `minVolumeUsd` filter). Pools dropped by the filter are not billed.

Typical run sizes:

- 1 network, top 20 pools → 20 rows
- 1 network, top 200 pools, $1k volume floor → ~80–150 rows
- 6 networks, 200 each → ~600–1200 rows
- 20 networks, 200 each → ~2000–4000 rows

***

### 🔄 Schedule for continuous monitoring

This scraper plays nicely with Apify's scheduler. Common patterns:

- **Every 5 minutes** — Solana memecoin / new-pool scanner (1 network, $5k volume floor)
- **Every 15 minutes** — multi-chain DEX trader feed (6 chains, $10k volume floor)
- **Hourly** — multichain liquidity dashboard refresh (20 chains, $1k volume floor)
- **Daily** — full multichain snapshot for analytics archive
- **Weekly** — deep historical sweep with low filters for research datasets

Use Apify Webhooks to push the dataset into TimescaleDB, BigQuery, Postgres, Google Sheets, Slack, Discord, Make.com, n8n or your own data warehouse.

***

### 🛠️ FAQ

**Do I need a GeckoTerminal API key?**
No. The public REST API requires no authentication and no signup.

**Which chains are supported?**
100+ networks including Ethereum, Solana, BSC, Base, Arbitrum, Polygon PoS, Avalanche, Optimism, Fantom, Cronos, PulseChain, Sui, TON, Aptos, Sei, Tron, Hyperliquid EVM, Berachain, Monad, Sonic, Linea, Mantle, Scroll, zkSync Era, Blast, Mode, Manta, Celo, Gnosis, Moonbeam, Moonriver, Harmony, Klaytn, Conflux, Cardano, Stellar, NEAR, MultiversX, Cosmos, Osmosis and many more.

**How do I find the right network slug?**
Visit [geckoterminal.com](https://www.geckoterminal.com), pick a chain in the network dropdown, look at the URL — the slug after `geckoterminal.com/` is the network slug (e.g. `eth`, `solana`, `polygon_pos`, `base`, `arbitrum`).

**Why max 200 pools per network?**
This is GeckoTerminal's public API limit (10 pages × 20 pools per page). For deeper coverage of a single network, use `dexscreener-token-pairs-scraper` with token addresses for the tokens you care about.

**How fresh is the data?**
Real-time. GeckoTerminal updates pool stats every few blocks from on-chain swap events.

**Can I filter to a specific DEX (e.g. only Uniswap V3)?**
Not from the input schema directly — the scraper returns all top pools per network. Filter by the `name` field downstream (e.g. names containing "0.05%" / "0.3%" / "1%" are Uniswap V3 tiers; "v2" suffix marks V2 pools; etc.).

**Can I get historical OHLCV / chart bars?**
Not from this scraper — this returns current snapshots. To build a time series, schedule this scraper at the desired interval and aggregate.

**What if a pool has no live volume?**
Pools with 0 or `null` volume24h are returned by the API but the `minVolumeUsd` filter will drop them if you set it.

**Does the actor respect GeckoTerminal's rate limits?**
Yes — built-in pacing and exponential backoff on HTTP 429. You can run unattended without getting throttled.

**How is this different from the DexScreener scrapers?**
GeckoTerminal and DexScreener are both DEX aggregators with overlapping but distinct coverage. GeckoTerminal is CoinGecko's official on-chain layer; DexScreener has its own indexer with strong memecoin / new-pair coverage. Many traders use BOTH for cross-verification.

**Can I export to CSV or Excel?**
Yes. Apify Dataset exports support JSON, CSV, Excel (XLSX), HTML and JSONL.

**Can I integrate via webhook / API?**
Yes. Apify provides REST API access to runs and datasets. Trigger from Zapier, Make.com, n8n, custom code, or any HTTP client.

***

### 📚 Related scrapers

Combine this DEX pools scraper with other crypto data scrapers in the suite to build a complete on-chain + spot + derivatives stack:

| Scraper | Purpose |
|---|---|
| **`geckoterminal-dex-pools-scraper`** | **You are here.** On-chain DEX pools across 100+ networks with price, FDV, reserve, volume, txns. |
| `coingecko-coins-market-scraper` | Full crypto market table — 17,000+ coins with price, market cap, volume, supply, ATH/ATL. |
| `coingecko-derivatives-scraper` | All 22,000+ derivative tickers (perpetuals + futures) with funding, OI, basis, volume. |
| `defillama-protocols-scraper` | All 7,000+ DeFi protocols with TVL, 1h/1d/7d TVL change, category, chains. |
| `defillama-yields-scraper` | DeFi yield-pool APYs (base + reward), TVL, IL risk, 1d/7d/30d APY trend. |
| `dexscreener-token-pairs-scraper` | Token contract → every live DEX pair across every chain. |
| `dexscreener-search-pairs-scraper` | Free-text symbol/name search → matching DEX pairs. |
| `crypto-exchange-tickers-scraper` | CEX spot ticker tables across exchanges. |

***

### 🔑 Keyword cloud

**Core:** geckoterminal api, geckoterminal scraper, dex pool scraper, dex liquidity scraper, on-chain price feed, multichain dex data, dex reserve api, dex volume tracker, dex price scraper, dex pool export.

**Per chain / DEX:** uniswap v3 pool data, uniswap v4 scraper, pancakeswap pool data, raydium pool scraper, orca pool data, meteora pool scraper, curve pool data, balancer pool data, aerodrome pool scraper, velodrome pool data, sushiswap pool data, quickswap pool data, trader joe scraper, camelot dex scraper, hyperliquid spot data, pump.fun scraper, cetus pool data, bluefin pool data, lifinity pool data.

**Per use case:** dex arbitrage data, memecoin scanner data, new dex pool discovery, mev searcher data, defi liquidity dashboard, on-chain analytics feed, dex market maker data, tokenomics research data, defi tvl research, multichain liquidity tracker, dex token discovery, on-chain price oracle data.

**Per audience:** dex data for traders, dex data for arbitrage bots, dex data for analysts, dex data for developers, on-chain data for portfolio apps, dex data for indexers, defi data for research desks, dex data for newsletter operators.

# Actor input Schema

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

Blockchain networks to scrape, e.g. 'eth', 'solana', 'bsc', 'base', 'arbitrum', 'polygon\_pos'. Each network yields up to 200 pools.

## `maxPoolsPerNetwork` (type: `integer`):

Maximum pools to fetch per network (up to 200). 0 = all.

## `minVolumeUsd` (type: `integer`):

Skip pools with 24h volume below this — filters out dead pools. 0 = no filter.

## Actor input object example

```json
{
  "networks": [
    "eth",
    "solana",
    "bsc",
    "base",
    "arbitrum",
    "polygon_pos"
  ],
  "maxPoolsPerNetwork": 50,
  "minVolumeUsd": 0
}
```

# Actor output Schema

## `name` (type: `string`):

name

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

network

## `baseTokenPriceUsd` (type: `string`):

baseTokenPriceUsd

## `volumeUsd24h` (type: `string`):

volumeUsd24h

## `reserveInUsd` (type: `string`):

reserveInUsd

## `priceChangePct24h` (type: `string`):

priceChangePct24h

## `txns24h` (type: `string`):

txns24h

# 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",
        "solana",
        "bsc",
        "base",
        "arbitrum",
        "polygon_pos"
    ],
    "maxPoolsPerNetwork": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/geckoterminal-dex-pools-scraper").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",
        "solana",
        "bsc",
        "base",
        "arbitrum",
        "polygon_pos",
    ],
    "maxPoolsPerNetwork": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/geckoterminal-dex-pools-scraper").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 '{
  "networks": [
    "eth",
    "solana",
    "bsc",
    "base",
    "arbitrum",
    "polygon_pos"
  ],
  "maxPoolsPerNetwork": 50
}' |
apify call logiover/geckoterminal-dex-pools-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/geckoterminal-dex-pools-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GeckoTerminal DEX Pools Scraper",
        "description": "Scrape live DEX liquidity pools from GeckoTerminal across 100+ blockchains — price, FDV, market cap, liquidity, 1h/6h/24h volume, price change and transaction counts. Thousands of pools per run. Schedule it for a continuously fresh on-chain feed.",
        "version": "0.1",
        "x-build-id": "9vqhrUorcWLiyvanc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~geckoterminal-dex-pools-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-geckoterminal-dex-pools-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~geckoterminal-dex-pools-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-geckoterminal-dex-pools-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~geckoterminal-dex-pools-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-geckoterminal-dex-pools-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "networks": {
                        "title": "Networks",
                        "type": "array",
                        "description": "Blockchain networks to scrape, e.g. 'eth', 'solana', 'bsc', 'base', 'arbitrum', 'polygon_pos'. Each network yields up to 200 pools.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPoolsPerNetwork": {
                        "title": "Max Pools Per Network",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum pools to fetch per network (up to 200). 0 = all."
                    },
                    "minVolumeUsd": {
                        "title": "Minimum 24h Volume (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip pools with 24h volume below this — filters out dead pools. 0 = no filter.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
