# DexScreener Scraper — DEX Pairs, Prices & Token Data (`bovi/dexscreener-scraper`) Actor

Scrape Dexscreener DEX market data — token pairs, USD/native price, liquidity, 24h volume, FDV, market cap across all chains. Search, pair, token and trending-profile modes. Public API, no key. Each record has parse\_confidence.

- **URL**: https://apify.com/bovi/dexscreener-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.45 / 1,000 dex pair 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

## Dexscreener Scraper — DEX Pairs, Token Prices & Trending | All Chains | from $1.50/1K

For DeFi traders, crypto market makers, and on-chain intelligence platforms that need structured pair data across all major blockchains — including real-time token prices, liquidity, FDV, and trending social metadata.

**No auth required.** All chains — Ethereum, Solana, BSC, Polygon, Arbitrum, Base and 50+ more. **$1.50/1,000 pair records** · **$3.00/1,000 token profiles** (Pay Per Event).

Scrape live DEX (decentralized exchange) trading pair data from Dexscreener
via the official public API. Search by token name or symbol, look up specific
pairs by chain and address, fetch all pairs for a token, or browse the latest
trending token profiles. No API key or authentication required.

### What data you get

Each DEX pair record includes:

| Field | Description |
|---|---|
| `chain_id` | Blockchain (ethereum, solana, bsc, polygon, arbitrum, base, …) |
| `dex_id` | DEX name (uniswap, raydium, pancakeswap, …) |
| `pair_address` | Pair contract address |
| `base_token_symbol` | Base token ticker (e.g. PEPE, BTC) |
| `base_token_name` | Base token full name |
| `base_token_address` | Base token contract address |
| `quote_token_symbol` | Quote token ticker (e.g. WETH, USDT) |
| `quote_token_name` | Quote token full name |
| `quote_token_address` | Quote token contract address |
| `price_usd` | Current price in USD |
| `price_native` | Current price in quote token units |
| `liquidity_usd` | Total liquidity in USD |
| `volume_24h` | 24-hour trading volume in USD |
| `price_change_24h` | % price change over the last 24 hours |
| `fdv` | Fully diluted valuation in USD |
| `market_cap` | Market cap in USD |
| `pair_created_at` | ISO 8601 date when the pair was created on-chain |
| `url` | Canonical Dexscreener URL |
| `parse_confidence` | Data quality score 0.0–1.0 |
| `warnings` | Machine-readable warning codes |

For `profiles` mode, `icon_url`, `description`, `website_url`, and `twitter_url`
are also populated.

### Modes

- **search** — Find pairs by token name or symbol. Each query returns up to 30 matching pairs across all chains and DEXes.
- **pairs** — Fetch specific pairs by `chain/pairAddress`. Up to 30 per chain in one call.
- **tokens** — Fetch all pairs for a token contract address (up to 30 per token).
- **profiles** — Fetch the latest trending token profiles with descriptions and social links.

### Use cases

- Crypto market monitoring dashboards
- DeFi arbitrage and liquidity analysis
- Token launch tracking and research
- On-chain data enrichment pipelines
- Meme coin discovery and trend analysis

### Pricing example

Pay per result (PPE). Charged per record pushed:

| Fetch | Records | Cost |
|---|---|---|
| Search "PEPE" (top 30 pairs) | 30 | ~$0.045 |
| 10 specific pair addresses | 10 | ~$0.015 |
| All pairs for 1 token address | up to 30 | ~$0.045 |
| Latest trending profiles (top ~30) | ~30 | ~$0.09 |
| 1,000 search results | 1,000 | ~$1.50 |

No proxy costs — Dexscreener API is fully public, zero infrastructure cost to you.

### FAQ

**Do I need a Dexscreener account or API key?**
No. The Dexscreener public API requires no authentication of any kind.

**What formats can I export to?**
JSON, CSV, and Excel via the Apify dataset or REST API. The flat schema maps directly to pandas or Google Sheets.

**Can I schedule this to run automatically?**
Yes. Schedule in Apify Console (e.g. every 5 minutes) or trigger via n8n / Make webhook to build a live on-chain monitoring feed.

**What if a query returns empty or a token address is invalid?**
Empty queries are skipped with a log warning. Invalid or unlisted token addresses return zero pairs — the actor logs and continues, no crash. Check `failedDetails` in the output for any failed lookups.

### Trust signal

Every record includes `parse_confidence` (1.0 = all expected fields present, below 1.0 = missing/unexpected data). Use this for downstream quality filtering without manual inspection.

### Competitor comparison

| Scraper | Chains | Price model | Social data? | parse_confidence? |
|---|---|---|---|---|
| **This actor** | 50+ chains | PPE $1.50–3/1K | yes (profiles mode) | yes |
| dextools-scraper (DOM) | Ethereum, BSC | rental | no | no |
| moralis-price-api (3rd-party) | 5 chains | $49/mo | no | no |
| dexscreener-unofficial | Some chains | flat fee | no | no |

### Use with AI agents (MCP)

This actor is callable as a **tool by AI agents** (Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client) via Apify's hosted Model Context Protocol server. An agent uses it to **look up on-chain token prices, liquidity, and trending DeFi pairs mid-conversation** — e.g. "what is the current price of PEPE on Ethereum?", "show me trending tokens with liquidity > $100K".

Point your MCP client at this tool:

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

Minimal input an agent can send:

```json
{ "mode": "search", "queries": ["PEPE"], "maxItems": 10 }
```

### Notes

- Official Dexscreener public API — no authentication required.
- Rate limits are generous; the actor adds small delays between batch calls.
- This actor is not affiliated with or endorsed by Dexscreener.

### Also in this finance family

- [CoinGecko Scraper](https://apify.com/bovi/coingecko-scraper) — live crypto prices, market caps, all coins
- [Binance Scraper](https://apify.com/bovi/binance-scraper) — spot prices + OHLCV klines for 3,500+ pairs
- [Yahoo Finance Scraper](https://apify.com/bovi/yahoo-finance-scraper) — stocks, ETFs, crypto, indices, forex
- [DefiLlama Scraper](https://apify.com/bovi/defillama-scraper) — DeFi protocol TVL + yield pool APY
- [ECB Exchange Rates Scraper](https://apify.com/bovi/exchange-rates-scraper) — historical FX rates back to 1999

### Integrations

Built for DeFi traders and on-chain intelligence platforms tracking live DEX pair prices, liquidity, and trending tokens — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

# Actor input Schema

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

What to scrape. search: find pairs by token name or symbol (e.g. PEPE, bitcoin). pairs: fetch specific pairs by chain + pair address. tokens: fetch all pairs for one or more token addresses. profiles: fetch the latest token profiles (trending tokens with descriptions and social links).

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

Token names or symbols to search (mode=search). Each query returns up to 30 matching DEX pairs. Examples: PEPE, bitcoin, shib, dogecoin.

## `pairAddresses` (type: `array`):

Pair addresses to fetch (mode=pairs). Each entry must be chain/pairAddress, e.g. ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852 or solana/J7XwW3tM2bEL2kQm9Ry. Up to 30 pairs can be fetched in one request.

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

Token contract addresses to look up (mode=tokens). Returns all trading pairs for each token across all DEXes. Examples: 0x6982508145454ce325ddbe47a25d4ec3d2311933 (PEPE on Ethereum).

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

Maximum total DEX pair records to output across all queries/addresses. 0 = no limit (up to API maximum per query). Default 100.

## `chain` (type: `string`):

Advanced: Filter results to a specific blockchain (mode=search or tokens). Leave empty for all chains. Examples: ethereum, solana, bsc, polygon, arbitrum, base, avalanche.

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

Advanced: Skip pairs with liquidity below this USD threshold. Useful for filtering out dust pairs. 0 = no filter (default).

## `minVolumeUsd24h` (type: `integer`):

Advanced: Skip pairs with 24h trading volume below this USD threshold. 0 = no filter (default).

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "PEPE",
    "bitcoin"
  ],
  "pairAddresses": [
    "ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852"
  ],
  "tokenAddresses": [
    "0x6982508145454ce325ddbe47a25d4ec3d2311933"
  ],
  "maxItems": 100
}
```

# Actor output Schema

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

Dataset containing Dexscreener Scraper records (chain\_id, dex\_id, base\_token\_symbol, quote\_token\_symbol, price\_usd, price\_change\_24h, volume\_24h, liquidity\_usd, market\_cap, pair\_created\_at, url, parse\_confidence).

# 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": [
        "PEPE",
        "bitcoin"
    ],
    "pairAddresses": [
        "ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852"
    ],
    "tokenAddresses": [
        "0x6982508145454ce325ddbe47a25d4ec3d2311933"
    ],
    "maxItems": 100,
    "minLiquidityUsd": 0,
    "minVolumeUsd24h": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/dexscreener-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 = {
    "mode": "search",
    "queries": [
        "PEPE",
        "bitcoin",
    ],
    "pairAddresses": ["ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852"],
    "tokenAddresses": ["0x6982508145454ce325ddbe47a25d4ec3d2311933"],
    "maxItems": 100,
    "minLiquidityUsd": 0,
    "minVolumeUsd24h": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/dexscreener-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 '{
  "mode": "search",
  "queries": [
    "PEPE",
    "bitcoin"
  ],
  "pairAddresses": [
    "ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852"
  ],
  "tokenAddresses": [
    "0x6982508145454ce325ddbe47a25d4ec3d2311933"
  ],
  "maxItems": 100,
  "minLiquidityUsd": 0,
  "minVolumeUsd24h": 0
}' |
apify call bovi/dexscreener-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DexScreener Scraper — DEX Pairs, Prices & Token Data",
        "description": "Scrape Dexscreener DEX market data — token pairs, USD/native price, liquidity, 24h volume, FDV, market cap across all chains. Search, pair, token and trending-profile modes. Public API, no key. Each record has parse_confidence.",
        "version": "0.1",
        "x-build-id": "4LJAPZgC268446cOG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~dexscreener-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-dexscreener-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/bovi~dexscreener-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-dexscreener-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/bovi~dexscreener-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-dexscreener-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": "Mode",
                        "enum": [
                            "search",
                            "pairs",
                            "tokens",
                            "profiles"
                        ],
                        "type": "string",
                        "description": "What to scrape. search: find pairs by token name or symbol (e.g. PEPE, bitcoin). pairs: fetch specific pairs by chain + pair address. tokens: fetch all pairs for one or more token addresses. profiles: fetch the latest token profiles (trending tokens with descriptions and social links)."
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Token names or symbols to search (mode=search). Each query returns up to 30 matching DEX pairs. Examples: PEPE, bitcoin, shib, dogecoin.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pairAddresses": {
                        "title": "Pair addresses",
                        "type": "array",
                        "description": "Pair addresses to fetch (mode=pairs). Each entry must be chain/pairAddress, e.g. ethereum/0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852 or solana/J7XwW3tM2bEL2kQm9Ry. Up to 30 pairs can be fetched in one request.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tokenAddresses": {
                        "title": "Token addresses",
                        "type": "array",
                        "description": "Token contract addresses to look up (mode=tokens). Returns all trading pairs for each token across all DEXes. Examples: 0x6982508145454ce325ddbe47a25d4ec3d2311933 (PEPE on Ethereum).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max pairs total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total DEX pair records to output across all queries/addresses. 0 = no limit (up to API maximum per query). Default 100."
                    },
                    "chain": {
                        "title": "Chain filter",
                        "type": "string",
                        "description": "Advanced: Filter results to a specific blockchain (mode=search or tokens). Leave empty for all chains. Examples: ethereum, solana, bsc, polygon, arbitrum, base, avalanche."
                    },
                    "minLiquidityUsd": {
                        "title": "Min liquidity (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Advanced: Skip pairs with liquidity below this USD threshold. Useful for filtering out dust pairs. 0 = no filter (default)."
                    },
                    "minVolumeUsd24h": {
                        "title": "Min 24h volume (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Advanced: Skip pairs with 24h trading volume below this USD threshold. 0 = no filter (default)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
