# DIA Crypto Price Oracle Scraper (`parseforge/dia-crypto-oracle-scraper`) Actor

Pull live crypto price oracle quotes from DIA across Bitcoin, Ethereum, Solana, and thousands of on-chain tokens. Resolve assets by ticker or blockchain and address. Returns symbol, name, USD price, prior day price, 24h volume, source, and timestamp for trading models and DeFi research.

- **URL**: https://apify.com/parseforge/dia-crypto-oracle-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.63 / 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)

## 💲 DIA Crypto Price Oracle Scraper

> 🚀 **Export live on-chain crypto oracle quotes in seconds.** Pull DIA price feeds for Bitcoin, Ethereum, Solana, and thousands of on-chain tokens by ticker or by blockchain and contract address.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 10 fields** per record · symbol or address resolution · live USD prices

Turn DIA's decentralized oracle into clean, structured quotes you can drop into a trading model, a DeFi dashboard, or a research notebook. Quote assets by ticker symbol (the highest-volume match wins), by exact blockchain and contract address, or leave both empty to pull the top quoted assets by 24h volume.

Coverage is whatever DIA publishes through its public oracle API: USD price, prior-day price, 24h volume, the originating source, and the quote timestamp, keyed by blockchain and on-chain address. No exchange account and no API key are required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Quant and trading teams | Feed oracle prices into models and alerts |
| DeFi builders and researchers | Read on-chain price feeds by chain and address |
| Portfolio and dashboard makers | Track USD prices and 24h volume across tokens |
| Analysts and journalists | Cite a dated, sourced price per asset |

### 📋 What the DIA Crypto Oracle Scraper does

This Actor calls the public DIA oracle API and returns one clean record per asset:

- **Quote by ticker** — pass symbols like `BTC`, `ETH`, `SOL`; each is resolved to its highest-volume blockchain and address, then quoted.
- **Quote by exact asset** — pass `blockchain` + `address` pairs for precise on-chain tokens (native coins use the zero address).
- **Top assets fallback** — leave both inputs empty to pull the top quoted assets ranked by 24h volume.

Each record carries the USD price, the prior-day price, the 24h USD volume, the source, the quote time, and a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `symbols` | array | Ticker symbols to resolve and quote (for example `BTC`, `ETH`, `SOL`). Each is matched against the DIA quoted-asset list, highest-volume match wins. |
| `assets` | array (JSON) | Exact assets to quote, each `{ "blockchain": "...", "address": "..." }`. Use for precise on-chain tokens; native coins use the zero address. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — quote by ticker symbol**
```json
{
    "symbols": ["BTC", "ETH", "SOL"],
    "maxItems": 10
}
````

**Example 2 — quote an exact on-chain asset**

```json
{
    "assets": [
        { "blockchain": "Ethereum", "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }
    ],
    "maxItems": 5
}
```

> ⚠️ **Good to Know:** When you pass a ticker, DIA may list it on several chains; the Actor picks the highest-volume match. For a specific token, use the `assets` list with the exact `blockchain` and `address`. If a symbol is not in the DIA quoted-asset list, the Actor returns a record with an explanatory `error` so nothing is silently dropped.

### 📊 Output

Each record represents a single oracle quote:

| Field | Description |
|---|---|
| 🏷 `symbol` | Asset ticker symbol |
| 📌 `name` | Asset name |
| ⛓ `blockchain` | Blockchain the asset is quoted on |
| 🔑 `address` | On-chain contract address (zero address for native coins) |
| 💲 `priceUsd` | Current USD price |
| 📉 `priceYesterdayUsd` | Prior-day USD price |
| 📊 `volumeYesterdayUsd` | 24h volume in USD |
| 🛰 `source` | The DIA source for the quote |
| 📅 `time` | Quote timestamp from DIA |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — Bitcoin**

```json
{
    "symbol": "BTC",
    "name": "Bitcoin",
    "blockchain": "Bitcoin",
    "address": "0x0000000000000000000000000000000000000000",
    "priceUsd": 67234.18,
    "priceYesterdayUsd": 66120.55,
    "volumeYesterdayUsd": 18254331022.4,
    "source": "diadata.org",
    "time": "2026-06-08T17:08:55.000Z",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — Ethereum**

```json
{
    "symbol": "ETH",
    "name": "Ether",
    "blockchain": "Ethereum",
    "address": "0x0000000000000000000000000000000000000000",
    "priceUsd": 3512.07,
    "priceYesterdayUsd": 3478.91,
    "volumeYesterdayUsd": 9123847710.2,
    "source": "diadata.org",
    "time": "2026-06-08T17:08:55.000Z",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — USDC by exact address**

```json
{
    "symbol": "USDC",
    "name": "USD Coin",
    "blockchain": "Ethereum",
    "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "priceUsd": 1.0001,
    "priceYesterdayUsd": 0.9999,
    "volumeYesterdayUsd": 4521903311.7,
    "source": "diadata.org",
    "time": "2026-06-08T17:08:55.000Z",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per asset, keyed by blockchain and contract address.
- Three ways to pick assets: ticker, exact address, or top-by-volume.
- USD price, prior-day price, and 24h volume in every record.
- Source and quote time included for auditability.
- No exchange account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | On-chain addressing | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Copying prices from a site | Repetitive | Inconsistent | No | Constant |
| Writing your own oracle client | Days | Depends | You own it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the DIA Crypto Price Oracle Scraper.
3. Enter `symbols` (for example `BTC`, `ETH`) or exact `assets` (blockchain + address).
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Trading and quant

| Goal | How this helps |
|---|---|
| Feed prices into a model | Get USD price and 24h volume per asset |
| Alert on moves | Compare price to prior-day price |

#### DeFi and on-chain

| Goal | How this helps |
|---|---|
| Read feeds by address | Quote exact tokens by blockchain and address |
| Audit a source | Each record carries source and quote time |

#### Portfolio and dashboards

| Goal | How this helps |
|---|---|
| Track a watchlist | Pass a list of tickers per run |
| Refresh on a schedule | Re-run to pull the latest quotes |

#### Research and reporting

| Goal | How this helps |
|---|---|
| Study market structure | Pull top assets by 24h volume |
| Cite dated prices | Use the source and time fields |

### 🔌 Automating DIA Crypto Oracle Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route quotes into sheets or databases.
- **Slack** to post price snapshots when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how oracle prices track across chains and sources.
- **Personal:** build your own crypto price tracker.
- **Non-profit:** power a transparent, public price resource.
- **Experimentation:** prototype a DeFi data app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results 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 assets by volume, compute day-over-day moves, or summarize the snapshot.

### ❓ Frequently Asked Questions

**Do I need a DIA account or API key?**
No. The Actor reads the public DIA oracle API, which needs no login.

**How does symbol resolution work?**
A ticker like `BTC` is matched against the DIA quoted-asset list, and the highest-volume match (its blockchain and address) is quoted.

**How do I quote an exact token?**
Use the `assets` input with the precise `blockchain` and `address`. Native coins use the zero address.

**What if a symbol is not found?**
The Actor returns a record with an `error` explaining the symbol was not in the DIA quoted-asset list.

**What happens if I leave both inputs empty?**
The Actor pulls the top quoted assets ranked by 24h volume, up to your `maxItems`.

**Which prices are included?**
Current USD price, prior-day USD price, and 24h USD volume, plus the source and quote time.

**Is there a logo or image field?**
No. The DIA response has no logo, so the Actor does not include an image field.

**How fresh are the quotes?**
Each run pulls live from DIA, so quotes reflect the oracle at run time.

**Can I quote tokens on chains other than Ethereum?**
Yes. Pass the matching `blockchain` name and `address` in the `assets` input.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot prices on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- More market and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

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

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

> **⚠️ Disclaimer:** independent tool, not affiliated with DIA. Only publicly available data is collected.

# Actor input Schema

## `symbols` (type: `array`):

Ticker symbols to resolve and quote, for example BTC, ETH, SOL. Each symbol is matched against the DIA quoted-asset list (highest-volume match wins) and quoted by its blockchain and contract address. Leave empty to use the Specific assets list or the top assets by volume.

## `assets` (type: `array`):

Exact assets to quote, each an object with 'blockchain' and 'address', for example {"blockchain":"Ethereum","address":"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"}. Use this for precise on-chain assets when a ticker is ambiguous. Native coins use the zero address.

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

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

## Actor input object example

```json
{
  "symbols": [
    "BTC",
    "ETH",
    "SOL"
  ],
  "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 = {
    "symbols": [
        "BTC",
        "ETH",
        "SOL"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/dia-crypto-oracle-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 = {
    "symbols": [
        "BTC",
        "ETH",
        "SOL",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/dia-crypto-oracle-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 '{
  "symbols": [
    "BTC",
    "ETH",
    "SOL"
  ],
  "maxItems": 10
}' |
apify call parseforge/dia-crypto-oracle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DIA Crypto Price Oracle Scraper",
        "description": "Pull live crypto price oracle quotes from DIA across Bitcoin, Ethereum, Solana, and thousands of on-chain tokens. Resolve assets by ticker or blockchain and address. Returns symbol, name, USD price, prior day price, 24h volume, source, and timestamp for trading models and DeFi research.",
        "version": "0.1",
        "x-build-id": "JWzJ9T0l02Un038Ud"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dia-crypto-oracle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-dia-crypto-oracle-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~dia-crypto-oracle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-dia-crypto-oracle-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~dia-crypto-oracle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-dia-crypto-oracle-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": {
                    "symbols": {
                        "title": "Asset symbols",
                        "type": "array",
                        "description": "Ticker symbols to resolve and quote, for example BTC, ETH, SOL. Each symbol is matched against the DIA quoted-asset list (highest-volume match wins) and quoted by its blockchain and contract address. Leave empty to use the Specific assets list or the top assets by volume.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "assets": {
                        "title": "Specific assets (blockchain + address)",
                        "type": "array",
                        "description": "Exact assets to quote, each an object with 'blockchain' and 'address', for example {\"blockchain\":\"Ethereum\",\"address\":\"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\"}. Use this for precise on-chain assets when a ticker is ambiguous. Native coins use the zero address."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```