# DexScreener Pairs & New-Pair Sniper (`xtracto/dexscreener-pairs`) Actor

Pull DEX trading pairs from DexScreener's open API: price, liquidity, FDV, volume, price-change. Search by query, snipe newest token profiles, track boosted tokens, or resolve pairs by token address. No auth.

- **URL**: https://apify.com/xtracto/dexscreener-pairs.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Integrations, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## DexScreener Pairs & New-Pair Sniper

Track newly listed token pairs and live market data — price, liquidity, market cap, FDV, and 24h / 6h / 1h / 5m trading volume — across **every blockchain DexScreener indexes** (Solana, Ethereum, Base, BSC, and more). Built for new-pair snipers, on-chain analysts, and token researchers who need a clean, structured feed.

### Why use this actor

- **No account, no API key, no login** — just press Run.
- **Catch new tokens the moment they list** — the *new pairs* feed surfaces freshly launched tokens, each enriched with full price, liquidity, market-cap and volume data.
- **Search any token or pair** by symbol, name, or contract address, and get every matching trading pair.
- **Every chain in one place** — filter to a single chain (e.g. Solana) or pull them all.
- **Rich per-pair detail** — buy/sell counts, price change over multiple time windows, liquidity depth, socials, and website links.
- **Clean, stable JSON** ready for spreadsheets, dashboards, databases, or alerting pipelines. Export to JSON, CSV, or Excel, and run it on a schedule.

### How it works

1. Pick a **mode**: search pairs by text, pull the newest listed tokens, list currently boosted tokens, or fetch all pairs for specific token contracts.
2. Fill in your queries or token addresses (or just use the prefilled examples).
3. Optionally set a **chain filter** (e.g. `solana`) and a **max records** cap.
4. Press **Run**. Results stream into the dataset as they are collected and can be exported to JSON, CSV, or Excel.

You don't manage any scrapers, servers, or blocks — the actor handles retries and pacing for you.

### Modes

| Mode | What it returns | Key input |
| --- | --- | --- |
| `search` *(default)* | Every trading pair matching a text query (symbol / name / address). | `queries` |
| `newPairs` | The newest listed tokens — the new-pair-sniper feed. | — |
| `boosts` | Tokens currently being promoted ("boosted") on DexScreener. | — |
| `tokens` | All trading pairs for specific token contract addresses. | `tokenAddresses` |

For `newPairs` and `boosts`, keep **Enrich pairs** on (default) to attach full price/liquidity/volume data to each token; turn it off for the lighter raw listing.

### Input

**Search mode (default):**
```json
{
  "mode": "search",
  "queries": ["SOL", "PEPE"],
  "chainFilter": "solana",
  "maxItems": 200
}
````

**New pairs mode:**

```json
{
  "mode": "newPairs",
  "enrichPairs": true,
  "chainFilter": "solana",
  "maxItems": 200
}
```

**Tokens mode:**

```json
{
  "mode": "tokens",
  "tokenAddresses": ["0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82"],
  "maxItems": 200
}
```

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | `search`, `newPairs`, `boosts`, or `tokens`. |
| `queries` | array of strings | Search mode: token symbols, names, or addresses to look up. |
| `tokenAddresses` | array of strings | Tokens mode: on-chain token contract addresses. |
| `enrichPairs` | boolean | New-pairs / boosts modes: attach full pair data to each token (default `true`). |
| `chainFilter` | string | Keep only one chain, e.g. `solana`, `ethereum`, `base`, `bsc`. Leave blank for all chains. |
| `maxItems` | integer | Maximum records to return (`0` = no cap). Default `200`. |
| `maxConcurrency` | integer | How aggressively to collect (default `4`). |
| `proxyConfiguration` | object | Optional. Not required — the data is public. |

### Output

Every record carries a small header (`_input`, `_scrapedAt`, `_source`, `recordType`) and a set of the most-used fields, followed by the full pair or token object with all original field names preserved. `recordType` is `PAIR`, `TOKEN_PROFILE`, or `BOOST`.

#### `PAIR` record — mode `search`, query `SOL`

```json
{
  "_input": "search:SOL",
  "_source": "S1-search",
  "_scrapedAt": "2026-07-09T11:07:30Z",
  "recordType": "PAIR",
  "chainId": "base",
  "dexId": "aerodrome",
  "pairAddress": "0x1131DB5977242a03eBeaD1aCD18F80A9A29e5922",
  "baseSymbol": "SOL",
  "baseName": "Solana",
  "baseAddress": "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82",
  "quoteSymbol": "USDC",
  "priceUsd": "77.62",
  "liquidityUsd": 382920.79,
  "fdv": 14734012,
  "marketCap": 14734012,
  "volumeH24": 3744071.42,
  "priceChangeH24": 0.46,
  "pairCreatedAt": null,
  "url": "https://dexscreener.com/base/0x1131db5977242a03ebead1acd18f80a9a29e5922",
  "priceNative": "77.6245",
  "txns": { "m5": {"buys": 1, "sells": 8}, "h1": {"buys": 146, "sells": 180}, "h24": {"buys": 4863, "sells": 5009} },
  "volume": { "h24": 3744071.42, "h6": 859526.49, "h1": 139637.47, "m5": 5441.26 },
  "priceChange": { "m5": -0.07, "h1": -0.6, "h6": -0.26, "h24": 0.46 },
  "liquidity": { "usd": 382920.79, "base": 3118.001739, "quote": 140887 },
  "baseToken": { "address": "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82", "name": "Solana", "symbol": "SOL" },
  "quoteToken": { "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "name": "USD Coin", "symbol": "USDC" },
  "info": { "websites": [{"url": "https://solana.com/", "label": "Website"}], "socials": [{"url": "https://x.com/solana", "type": "twitter"}] }
}
```

#### `PAIR` record — mode `newPairs` (a freshly launched token)

```json
{
  "_input": "newPairs:4YaUff21q1aHWkB625NvGdEHR8Gr3MytHLvSWqp4pump",
  "_source": "S1-newpairs",
  "_scrapedAt": "2026-07-09T15:49:40Z",
  "recordType": "PAIR",
  "chainId": "solana",
  "dexId": "pumpfun",
  "pairAddress": "3MSGVj1T1AUhpSaiQMkuc1ALgxMM1eHBJnNPUS3zJNYh",
  "baseSymbol": "COPYCAT",
  "baseName": "COPYCAT",
  "baseAddress": "4YaUff21q1aHWkB625NvGdEHR8Gr3MytHLvSWqp4pump",
  "quoteSymbol": "SOL",
  "priceUsd": "0.000004244",
  "liquidityUsd": null,
  "fdv": 4244.67,
  "marketCap": 4244.67,
  "volumeH24": 24863.17,
  "priceChangeH24": 88.15,
  "pairCreatedAt": 1783611540000,
  "txns": { "m5": {"buys": 137, "sells": 143}, "h1": {"buys": 413, "sells": 331} },
  "volume": { "h24": 24863.17, "m5": 7717.61 },
  "priceChange": { "m5": -41.8, "h1": 88.15, "h24": 88.15 },
  "baseToken": { "address": "4YaUff21q1aHWkB625NvGdEHR8Gr3MytHLvSWqp4pump", "name": "COPYCAT", "symbol": "COPYCAT" },
  "quoteToken": { "address": "So11111111111111111111111111111111111111112", "name": "Wrapped SOL", "symbol": "SOL" },
  "info": { "websites": [{"url": "https://copycatpf.org/", "label": "Website"}] }
}
```

#### `BOOST` record — mode `boosts` (Enrich pairs off)

```json
{
  "_input": "boosts",
  "_source": "S1-boosts",
  "_scrapedAt": "2026-07-09T15:49:36Z",
  "recordType": "BOOST",
  "chainId": "solana",
  "tokenAddress": "9motHbNmm4Km8u7VYGhg6xJWN5Ro9XDKYmEkaMMYpump",
  "description": "FELLOW HOODRATS \n\nTHE HOOD STAYS ON\n\nHOODRAT'S FOR LIFE",
  "url": "https://dexscreener.com/solana/9mothbnmm4km8u7vyghg6xjwn5ro9xdkymekammypump",
  "links": [{ "type": "twitter", "url": "https://x.com/i/communities/1955460209717153825" }],
  "totalAmount": 40,
  "amount": 30
}
```

#### Key output fields

| Field | Type | Description |
| --- | --- | --- |
| `recordType` | string | `PAIR`, `TOKEN_PROFILE`, or `BOOST`. |
| `chainId` | string | Blockchain the pair trades on (e.g. `solana`, `base`). |
| `dexId` | string | Exchange the pair trades on (e.g. `pumpfun`, `aerodrome`). |
| `pairAddress` | string | On-chain address of the trading pair. |
| `baseSymbol` / `baseName` / `baseAddress` | string | The traded token's symbol, name, and contract. |
| `quoteSymbol` | string | The token it's priced against (e.g. USDC, SOL). |
| `priceUsd` | string | Current price in USD. |
| `liquidityUsd` | number | Pool liquidity in USD. |
| `fdv` / `marketCap` | number | Fully diluted valuation and market cap in USD. |
| `volumeH24` | number | 24-hour trading volume in USD (also `volume` for 6h/1h/5m). |
| `priceChangeH24` | number | 24-hour price change % (also `priceChange` for shorter windows). |
| `txns` | object | Buy / sell counts per time window. |
| `pairCreatedAt` | number | Pair creation time (ms since epoch), when available. |
| `info` | object | Websites, socials, and image links, when available. |
| `totalAmount` / `amount` | number | *Boosts only* — the promotion amount on the token. |

On any failure the actor emits a `{_input, _source, _scrapedAt, _error, _errorDetail}` record instead of silently skipping.

### Notes & limits

- All data is public — no account or key needed. A proxy is optional.
- The new-pairs and boosts feeds return roughly the newest ~30 entries per run; run on a schedule to build a continuous history.
- Use `chainFilter` to focus on one chain and `maxItems` to cap large runs.
- Prices and volumes are a live snapshot at run time.

# Actor input Schema

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

What to pull. 'search' = query DexScreener for pairs by text (uses 'queries'). 'newPairs' = newest listed token profiles (the new-pair-sniper feed). 'boosts' = currently boosted tokens. 'tokens' = all pairs for specific token addresses (uses 'tokenAddresses').

## `queries` (type: `array`):

Used when mode = 'search'. Free-text queries (token symbol, name, pair address, or token address), e.g. \["SOL", "PEPE", "0x..."]. Each query hits /latest/dex/search and every returned pair is emitted.

## `tokenAddresses` (type: `array`):

Used when mode = 'tokens'. On-chain token contract addresses; each is resolved via /latest/dex/tokens/{address} and all of its pairs are emitted.

## `enrichPairs` (type: `boolean`):

Used when mode = 'newPairs' or 'boosts'. If checked, each token in the feed is enriched by calling /latest/dex/tokens/{address} to pull full pair data (price, liquidity, FDV, volume). If unchecked, the raw token profile/boost entry is emitted instead (fewer requests).

## `chainFilter` (type: `string`):

Optional. Keep only pairs/tokens on this chainId, e.g. 'solana', 'ethereum', 'base', 'bsc'. Leave blank for all chains.

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

Maximum records to push to the dataset (0 = no cap). Applied across all queries/tokens in the run.

## `maxConcurrency` (type: `integer`):

Number of parallel HTTP requests. Kept low to respect DexScreener's ~300 req/min public rate limit.

## `proxyConfiguration` (type: `object`):

Optional. DexScreener is a public no-auth API, so proxy is not required; datacenter proxy is fine. Defaults to the Apify Residential group.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "SOL",
    "PEPE"
  ],
  "tokenAddresses": [
    "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82"
  ],
  "enrichPairs": true,
  "chainFilter": "solana",
  "maxItems": 200,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "search",
    "queries": [
        "SOL",
        "PEPE"
    ],
    "tokenAddresses": [
        "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82"
    ],
    "chainFilter": "solana",
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/dexscreener-pairs").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": "search",
    "queries": [
        "SOL",
        "PEPE",
    ],
    "tokenAddresses": ["0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82"],
    "chainFilter": "solana",
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/dexscreener-pairs").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": "search",
  "queries": [
    "SOL",
    "PEPE"
  ],
  "tokenAddresses": [
    "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82"
  ],
  "chainFilter": "solana",
  "maxItems": 200
}' |
apify call xtracto/dexscreener-pairs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtracto/dexscreener-pairs",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DexScreener Pairs & New-Pair Sniper",
        "description": "Pull DEX trading pairs from DexScreener's open API: price, liquidity, FDV, volume, price-change. Search by query, snipe newest token profiles, track boosted tokens, or resolve pairs by token address. No auth.",
        "version": "0.1",
        "x-build-id": "TiasANA5kQiJTOYLw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~dexscreener-pairs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-dexscreener-pairs",
                "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/xtracto~dexscreener-pairs/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-dexscreener-pairs",
                "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/xtracto~dexscreener-pairs/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-dexscreener-pairs",
                "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": "Mode",
                        "enum": [
                            "search",
                            "newPairs",
                            "boosts",
                            "tokens"
                        ],
                        "type": "string",
                        "description": "What to pull. 'search' = query DexScreener for pairs by text (uses 'queries'). 'newPairs' = newest listed token profiles (the new-pair-sniper feed). 'boosts' = currently boosted tokens. 'tokens' = all pairs for specific token addresses (uses 'tokenAddresses').",
                        "default": "search"
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Used when mode = 'search'. Free-text queries (token symbol, name, pair address, or token address), e.g. [\"SOL\", \"PEPE\", \"0x...\"]. Each query hits /latest/dex/search and every returned pair is emitted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tokenAddresses": {
                        "title": "Token addresses",
                        "type": "array",
                        "description": "Used when mode = 'tokens'. On-chain token contract addresses; each is resolved via /latest/dex/tokens/{address} and all of its pairs are emitted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichPairs": {
                        "title": "Enrich feed with full pair data",
                        "type": "boolean",
                        "description": "Used when mode = 'newPairs' or 'boosts'. If checked, each token in the feed is enriched by calling /latest/dex/tokens/{address} to pull full pair data (price, liquidity, FDV, volume). If unchecked, the raw token profile/boost entry is emitted instead (fewer requests).",
                        "default": true
                    },
                    "chainFilter": {
                        "title": "Chain filter",
                        "type": "string",
                        "description": "Optional. Keep only pairs/tokens on this chainId, e.g. 'solana', 'ethereum', 'base', 'bsc'. Leave blank for all chains.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max records (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to push to the dataset (0 = no cap). Applied across all queries/tokens in the run.",
                        "default": 200
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of parallel HTTP requests. Kept low to respect DexScreener's ~300 req/min public rate limit.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. DexScreener is a public no-auth API, so proxy is not required; datacenter proxy is fine. Defaults to the Apify Residential group.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
