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

Track trending and newly created liquidity pools from GeckoTerminal across Ethereum, Solana, Base, and 100 more chains. Returns pool name, DEX, base and quote token prices, FDV, USD reserves, 24 hour volume, and buy and sell counts. Great for trading signals and DeFi research.

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

## Pricing

from $0.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🦎 GeckoTerminal DEX Pools Scraper

> 🚀 **Export live on-chain DEX pool data in seconds.** Pull trending, new, and searched liquidity pools across 100+ blockchains with prices, volume, FDV, reserves, and trade counts in clean tabular rows.

> 🕒 **Last updated:** 2026-06-04 · **📊 15 fields** per record · 100+ chains · trending, new, search, and single-pool modes

GeckoTerminal tracks real-time decentralized exchange (DEX) activity across Ethereum, Solana, BNB Chain, Base, Arbitrum, and dozens of other networks. This Actor turns that on-chain feed into structured records you can drop straight into a spreadsheet, a dashboard, or a trading model. Point it at a network for trending or newly created pools, run a token search, or fetch a single pool by its contract address.

Each row flattens GeckoTerminal's nested API into clean columns: pool name and address, the DEX it lives on, base and quote token prices in USD, fully diluted valuation, market cap, USD reserves, 24 hour volume, 24 hour price change, and buy and sell counts. No key, no login, no proxy juggling.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto traders and quant researchers | Spotting trending and freshly launched pools |
| DeFi analysts and data teams | Tracking liquidity, volume, and price momentum |
| Builders of dashboards and bots | Feeding live pool metrics into apps and models |
| Market intelligence and content teams | Monitoring DEX activity across many chains |

### 📋 What the GeckoTerminal DEX Pools Scraper does

- Pulls **trending pools** for any supported network (default Ethereum).
- Pulls **newly created pools** to catch fresh launches early.
- Runs a **pool search** by token symbol, name, or address.
- Fetches a **single pool by contract address** for deep tracking.
- Resolves the **DEX name** (Uniswap V2, Uniswap V3, and others) for every pool.
- Flattens prices, volume, FDV, market cap, reserves, and trade counts into one row each.
- Covers **100+ blockchains** including Ethereum, Solana, BNB Chain, Base, Arbitrum, Polygon, Optimism, and Avalanche.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | What to scrape. `trending`, `new`, `search`, or `pool`. |
| `searchQuery` | string | Token symbol, name, or address. Used in `search` mode. |
| `poolAddress` | string | Pool contract address. Used in `pool` mode. |
| `network` | select | Blockchain to read from. Defaults to `eth`. |
| `maxItems` | integer | Cap on records returned. Free plan is limited to 10. |

Example 1. Trending pools on Ethereum.

```json
{
  "mode": "trending",
  "network": "eth",
  "maxItems": 20
}
````

Example 2. Search for PEPE pools on Ethereum.

```json
{
  "mode": "search",
  "searchQuery": "PEPE",
  "network": "eth",
  "maxItems": 20
}
```

> ⚠️ **Good to Know:** GeckoTerminal fills `marketCapUsd` only when a verified circulating supply is available, so for many newer or smaller tokens it stays empty while `fdvUsd` is still present. The public API is rate limited to roughly 30 calls per minute, which a single list run stays well within.

### 📊 Output

Each record contains these fields.

| Field | Description |
|---|---|
| 📌 `poolName` | Pool pair name, for example SPCX / WETH |
| 🔁 `dexName` | Exchange hosting the pool, for example Uniswap V3 |
| ⛓ `network` | Blockchain the pool lives on |
| 💲 `baseTokenPriceUsd` | Base token price in USD |
| 💵 `quoteTokenPriceUsd` | Quote token price in USD |
| 📊 `fdvUsd` | Fully diluted valuation in USD |
| 🏦 `marketCapUsd` | Market cap in USD when available |
| 💧 `reserveUsd` | Total pool reserve in USD |
| 📈 `volumeUsd24h` | 24 hour trading volume in USD |
| 🔺 `priceChange24h` | 24 hour price change percent |
| 🟢 `buys24h` | Buy transactions in the last 24 hours |
| 🔴 `sells24h` | Sell transactions in the last 24 hours |
| 🔗 `poolAddress` | On-chain pool contract address |
| 🕓 `poolCreatedAt` | Pool creation timestamp |
| 🕒 `scrapedAt` | When the record was collected |

Three real sample records from a trending Ethereum run.

```json
{
  "poolAddress": "0x4438a8af0231b27f54da4b6c32a56d1357b369e7",
  "poolName": "SPCX / WETH",
  "dexName": "Uniswap V2",
  "network": "eth",
  "baseTokenPriceUsd": "0.00204584000315499",
  "quoteTokenPriceUsd": "1778.26268089588",
  "fdvUsd": "2045840.003",
  "marketCapUsd": null,
  "reserveUsd": "115878.1759",
  "volumeUsd24h": "1171486.84066408",
  "priceChange24h": "61.793",
  "buys24h": 1532,
  "sells24h": 869,
  "poolCreatedAt": "2026-05-25T00:54:11Z",
  "scrapedAt": "2026-06-04T20:02:26.555Z",
  "error": null
}
```

```json
{
  "poolAddress": "0x12d44f8b4d3e28bdeb35e8e2e6585dfcc33eda5f",
  "poolName": "DOGEUS / WETH",
  "dexName": "Uniswap V2",
  "network": "eth",
  "baseTokenPriceUsd": "0.00571235851235865",
  "quoteTokenPriceUsd": "1778.26268089588",
  "fdvUsd": "5719424.855",
  "marketCapUsd": null,
  "reserveUsd": "222303.1073",
  "volumeUsd24h": "1629275.52449498",
  "priceChange24h": "-25.359",
  "buys24h": 2234,
  "sells24h": 1746,
  "poolCreatedAt": "2026-05-27T13:15:35Z",
  "scrapedAt": "2026-06-04T20:02:26.675Z",
  "error": null
}
```

```json
{
  "poolAddress": "0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
  "poolName": "WETH / USDC 0.05%",
  "dexName": "Uniswap V3",
  "network": "eth",
  "baseTokenPriceUsd": "1778.60735970741",
  "quoteTokenPriceUsd": "1.0028681007648",
  "fdvUsd": "4228108953.06114",
  "marketCapUsd": "4224881911.21596",
  "reserveUsd": "89574090.1016",
  "volumeUsd24h": "269856482.011789",
  "priceChange24h": "-1.164",
  "buys24h": 6219,
  "sells24h": 5133,
  "poolCreatedAt": "2021-12-29T12:35:14Z",
  "scrapedAt": "2026-06-04T20:02:26.725Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Four modes in one tool.** Trending, new, search, and single pool, no extra setup.
- **Broad chain coverage.** 100+ networks from Ethereum and Solana to Base and Arbitrum.
- **Clean flat rows.** GeckoTerminal's nested JSON:API is unpacked into named columns.
- **No key, no login.** The source is keyless, so runs start instantly.
- **Honest fields.** Empty values stay empty rather than guessed, so your data stays trustworthy.

### 📈 How it compares to alternatives

| Approach | Coverage | Setup | Structured rows |
|---|---|---|---|
| This Actor | 100+ chains, four modes | None, keyless | Yes, flat columns |
| Manual site browsing | One pool at a time | Click heavy | No |
| Raw API calls yourself | Full but nested | Header and paging work | Only after parsing |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the GeckoTerminal DEX Pools Scraper from your Apify console.
3. Pick a `mode` and a `network`, then add a `searchQuery` or `poolAddress` if needed.
4. Set `maxItems` and click **Start**.
5. Watch rows appear, then pull them from the dataset when the run finishes.

### 💼 Business use cases

#### Trading and research

| Goal | How this helps |
|---|---|
| Spot momentum | Trending pools ranked with 24 hour volume and price change |
| Catch launches | New pools mode surfaces fresh pairs early |

#### Liquidity monitoring

| Goal | How this helps |
|---|---|
| Track depth | Reserve in USD per pool across chains |
| Watch flow | Buy and sell counts over the last 24 hours |

#### Market intelligence

| Goal | How this helps |
|---|---|
| Map a token | Search mode finds every pool for a symbol |
| Compare chains | Run the same query across many networks |

#### Dashboards and bots

| Goal | How this helps |
|---|---|
| Feed an app | Flat rows drop straight into a database |
| Schedule pulls | Run on a timer for a rolling snapshot |

### 🔌 Automating GeckoTerminal DEX Pools Scraper

Connect runs to the tools you already use.

- **Make** and **Zapier** to trigger workflows on each finished run.
- **Slack** to post new trending pools to a channel.
- **Airbyte** to sync the dataset into a warehouse.
- **GitHub** Actions to schedule recurring pulls.
- **Google Drive** to archive snapshots for later analysis.

### 🌟 Beyond business use cases

- **Research.** Study DEX behavior, liquidity migration, and launch patterns.
- **Personal.** Keep an eye on tokens you hold across several chains.
- **Non-profit.** Support open transparency work around on-chain markets.
- **Experimentation.** Prototype trading signals and alerting ideas.

### 🤖 Ask an AI assistant

Paste a few rows into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to rank pools by volume, flag unusual buy and sell ratios, or summarize momentum across chains.

### ❓ Frequently Asked Questions

**Which networks are supported?**
Over 100, including Ethereum, Solana, BNB Chain, Base, Arbitrum, Polygon, Optimism, and Avalanche. Ethereum is the default.

**What does each mode do?**
Trending returns ranked active pools, New returns freshly created ones, Search finds pools by query, and Pool fetches a single pool by address.

**Do I need an API key?**
No. GeckoTerminal's public on-chain endpoints are keyless, so the Actor runs without any credentials.

**Why is marketCapUsd sometimes empty?**
GeckoTerminal only reports market cap when a verified circulating supply exists. For many newer tokens it stays empty while FDV is still populated.

**Are the prices live?**
Yes. Each run reads the current values from GeckoTerminal at the moment it runs.

**How many pools can one run return?**
List endpoints return up to 20 pools per call. Free plan runs are capped at 10 items, while paid plans can go higher.

**Can I track one specific pool over time?**
Yes. Use Pool mode with the pool contract address and schedule the run on a timer.

**What does the search query accept?**
A token symbol, a token name, or a pool address. Combine it with a network to narrow results.

**Are the numbers strings or numbers?**
Price and value fields are kept as the source provides them to preserve full precision. Buy and sell counts are integers.

**Is there a rate limit?**
The public source allows roughly 30 calls per minute. A single list run stays comfortably inside that.

**What happens if a request fails?**
The Actor writes a single record with an `error` field describing the problem so a run never fails silently.

**Can I export the data?**
Yes. Results land in a standard Apify dataset you can pull through the API or the console.

### 🔌 Integrate with any app

Every run writes to an Apify dataset reachable through the Apify API, so you can wire it into databases, spreadsheets, BI tools, and custom services with a single endpoint.

### 🔗 Recommended Actors

- [CoinGecko Scraper](https://apify.com/parseforge/coingecko-scraper) for broad coin prices and market data.
- [DefiLlama Scraper](https://apify.com/parseforge/defillama-scraper) for protocol and chain TVL.
- [DexScreener Scraper](https://apify.com/parseforge/dexscreener-scraper) for more DEX pair tracking.
- [CoinMarketCap Scraper](https://apify.com/parseforge/coinmarketcap-scraper) for ranked market caps and listings.
- [Birdeye Token Trending Scraper](https://apify.com/parseforge/birdeye-token-trending-scraper) for trending tokens on Solana and beyond.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool, not affiliated with GeckoTerminal or CoinGecko. Only publicly available data is collected.

# Actor input Schema

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

Pick the kind of pool data to pull. Trending and New return a ranked list for the chosen network. Search finds pools matching a query. Pool by address returns one specific pool.

## `searchQuery` (type: `string`):

Only used when Mode is Search. Token symbol, name, or pool address to look up, for example PEPE or WETH.

## `poolAddress` (type: `string`):

Only used when Mode is Pool by address. The on-chain liquidity pool contract address.

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

Which chain to read pools from. Defaults to Ethereum. Applies to Trending, New, Pool, and narrows Search.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "mode": "trending",
  "searchQuery": "PEPE",
  "network": "eth",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "searchQuery": "PEPE",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchQuery": "PEPE",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchQuery": "PEPE",
  "maxItems": 10
}' |
apify call parseforge/geckoterminal-dex-pools-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GeckoTerminal DEX Pools Scraper",
        "description": "Track trending and newly created liquidity pools from GeckoTerminal across Ethereum, Solana, Base, and 100 more chains. Returns pool name, DEX, base and quote token prices, FDV, USD reserves, 24 hour volume, and buy and sell counts. Great for trading signals and DeFi research.",
        "version": "0.1",
        "x-build-id": "4f3wZSbDiXwjOeRMy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~geckoterminal-dex-pools-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~geckoterminal-dex-pools-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~geckoterminal-dex-pools-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "trending",
                            "new",
                            "search",
                            "pool"
                        ],
                        "type": "string",
                        "description": "Pick the kind of pool data to pull. Trending and New return a ranked list for the chosen network. Search finds pools matching a query. Pool by address returns one specific pool.",
                        "default": "trending"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Only used when Mode is Search. Token symbol, name, or pool address to look up, for example PEPE or WETH."
                    },
                    "poolAddress": {
                        "title": "Pool address",
                        "type": "string",
                        "description": "Only used when Mode is Pool by address. The on-chain liquidity pool contract address."
                    },
                    "network": {
                        "title": "Blockchain network",
                        "enum": [
                            "eth",
                            "solana",
                            "bsc",
                            "base",
                            "arbitrum",
                            "polygon_pos",
                            "optimism",
                            "avax",
                            "ftm",
                            "blast",
                            "linea",
                            "zksync",
                            "mantle",
                            "scroll",
                            "sui-network",
                            "ton",
                            "aptos",
                            "pulsechain",
                            "core",
                            "sei-network",
                            "merlin-chain",
                            "xdai",
                            "celo",
                            "cro",
                            "kaia",
                            "ronin",
                            "metis",
                            "mode",
                            "manta-pacific",
                            "zetachain"
                        ],
                        "type": "string",
                        "description": "Which chain to read pools from. Defaults to Ethereum. Applies to Trending, New, Pool, and narrows Search.",
                        "default": "eth"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
