# DIA Crypto Price Oracle Scraper (`parseforge/bank-of-england-iadb-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/bank-of-england-iadb-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 $4.98 / 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)

## 🏦 Bank of England IADB Scraper

> 🚀 **Export UK macro and financial time series in seconds.** Pull the official Bank Rate, SONIA, bond yields, mortgage rates, and money supply straight from the Bank of England Interactive Database by series code.

> 🕒 **Last updated:** 2026-06-08 · **📊 4 fields** per record · multi-series · one record per date and series

Turn the Bank of England Interactive Database (IADB) into clean, structured observations you can drop into a dashboard, a model, or a spreadsheet. Give it one or more IADB series codes and a date window, and get one tidy record per date and series with the value already parsed as a number.

Coverage is whatever the public IADB publishes: official Bank Rate, SONIA, government bond yields, representative mortgage rates, household interest rates, and the M4 money supply aggregates, among thousands of other series. You pick the codes and the period; the Actor handles the IADB date formats and CSV export for you.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Economists and analysts | Track Bank Rate, SONIA, and yields over time |
| Quant and risk teams | Feed UK rates into models and backtests |
| Dashboard and BI builders | Seed a time-series panel with official data |
| Researchers and journalists | Cite a clean, dated record per observation |

### 📋 What the Bank of England IADB Scraper does

This Actor calls the public Bank of England IADB CSV export and returns one clean record per observation:

- **One record per date and series** — every non-empty value in your date window becomes its own row.
- **Multiple series in one run** — pass several codes and each becomes its own labelled record.
- **Parsed values** — the raw CSV value is returned as a JavaScript number, with the original IADB date label and an ISO date alongside.

You control which series codes to pull, the date window, and how many records come back. Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `seriesCodes` | array | One or more IADB series codes to pull. Each code becomes one labelled record per date. Defaults to `["IUDBEDR"]` (official Bank Rate). |
| `dateFrom` | string | Start of the date window. Accepts ISO (`2026-01-01`) or IADB (`01/Jan/2026`). Empty defaults to one year before today. |
| `dateTo` | string | End of the date window. Accepts ISO, IADB, or the word `now` for the latest available date. Empty defaults to today. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — the official Bank Rate over a date window**
```json
{
    "seriesCodes": ["IUDBEDR"],
    "dateFrom": "2026-01-01",
    "dateTo": "now",
    "maxItems": 100
}
````

**Example 2 — several rates at once**

```json
{
    "seriesCodes": ["IUDBEDR", "IUDSOIA", "IUDMNZC"],
    "dateFrom": "2025-01-01",
    "dateTo": "2026-06-01",
    "maxItems": 500
}
```

> ⚠️ **Good to Know:** Common codes include `IUDBEDR` (official Bank Rate), `IUDSOIA` (SONIA), `IUDMNZC` (10y government bond yield), `IUMABEDR` (monthly average Bank Rate), `IUMBV34` (2y fixed 75% LTV mortgage rate), `IUMTLMV` (representative household interest rate), and `LPMVWYH` / `LPMAUYN` (M4 money supply). Find more codes on the IADB site. Different series publish at different frequencies (daily, monthly, quarterly), so the number of observations per series varies.

### 📊 Output

Each record represents a single observation:

| Field | Description |
|---|---|
| 🏷 `seriesCode` | The IADB series code this value belongs to |
| 📅 `date` | The IADB date label for the observation |
| 📈 `value` | The observation value as a number (null if blank) |
| 🗓 `isoDate` | The same date in ISO `YYYY-MM-DD` form |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — Bank Rate observation**

```json
{
    "seriesCode": "IUDBEDR",
    "date": "02 Jan 2026",
    "value": 4.5,
    "isoDate": "2026-01-02",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — SONIA observation**

```json
{
    "seriesCode": "IUDSOIA",
    "date": "05 Jan 2026",
    "value": 4.43,
    "isoDate": "2026-01-05",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — bond yield observation**

```json
{
    "seriesCode": "IUDMNZC",
    "date": "06 Jan 2026",
    "value": 4.62,
    "isoDate": "2026-01-06",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per observation, ready to chart or model.
- Multiple series in a single run, each row tagged with its `seriesCode`.
- Flexible date input: ISO, IADB format, or `now` all work.
- Values come back as numbers, not strings, with an ISO date for easy sorting.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Date handling | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Automatic | None on your side |
| Downloading CSVs by hand | Repetitive | Manual parsing | Manual | Constant |
| Writing your own IADB 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 Bank of England IADB Scraper.
3. Enter one or more `seriesCodes` (for example `IUDBEDR`).
4. Set `dateFrom`, `dateTo`, and `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Economic research

| Goal | How this helps |
|---|---|
| Track UK monetary policy | Pull Bank Rate and SONIA over any window |
| Study yield movements | Snapshot bond yield series alongside rates |

#### Risk and quant

| Goal | How this helps |
|---|---|
| Feed rates into models | Get numeric values keyed by date and series |
| Backtest against history | Pull long date windows per series |

#### Dashboards and BI

| Goal | How this helps |
|---|---|
| Seed a time-series panel | One record per date and series, ready to load |
| Refresh on a schedule | Re-run to append the latest observations |

#### Media and reporting

| Goal | How this helps |
|---|---|
| Cite official figures | Each record carries its source series and date |
| Build rate charts | Use the numeric value and ISO date fields |

### 🔌 Automating Bank of England IADB Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary 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:** assemble a clean dataset of UK rates for a paper or thesis.
- **Personal:** track the Bank Rate that affects your mortgage.
- **Non-profit:** power a public-interest economics resource.
- **Experimentation:** prototype a rates dashboard 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 chart the Bank Rate, compare series, or summarize how rates moved over a period.

### ❓ Frequently Asked Questions

**Do I need a Bank of England account or API key?**
No. The Actor reads the public IADB CSV export, which needs no login.

**How do I find series codes?**
Browse the Bank of England Interactive Database on their site. Common codes are listed in the input description and the Good to Know note above.

**Can I pull several series at once?**
Yes. Add multiple codes to `seriesCodes`; each value is tagged with its `seriesCode` in the output.

**What date formats are accepted?**
ISO like `2026-01-01`, IADB like `01/Jan/2026`, and the word `now` for the latest available date.

**What happens to gaps in a series?**
Blank cells (days a series does not publish) are skipped, so you only get real observations.

**Why do some series have fewer records than others?**
Series publish at different frequencies (daily, monthly, quarterly), so the count varies per code and window.

**Are values numbers or text?**
Values come back as numbers. The original IADB date label is kept in `date`, with an ISO version in `isoDate`.

**What if a code is invalid?**
The Actor reports an error record explaining no data was returned for that code or window.

**How fresh is the data?**
Each run pulls live from the IADB, so it reflects the latest published observations at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot series 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 economic 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 the Bank of England. Only publicly available data is collected.

# Actor input Schema

## `seriesCodes` (type: `array`):

One or more Bank of England IADB series codes to pull. Each code becomes a column in the source export and one record per date and series in the output. Common codes: IUDBEDR (official Bank Rate), IUDSOIA (SONIA), IUDMNZC (10y government bond yield), IUMABEDR (monthly average Bank Rate), IUMBV34 (2y fixed 75% LTV mortgage rate), IUMTLMV (representative household interest rate), LPMVWYH and LPMAUYN (money supply M4). Find more codes on the IADB site.

## `dateFrom` (type: `string`):

Start of the date window. Accepts ISO format like 2026-01-01 or the IADB format 01/Jan/2026. Leave empty to default to one year before today.

## `dateTo` (type: `string`):

End of the date window. Accepts ISO format like 2026-06-01, the IADB format 01/Jun/2026, or the word 'now' for the latest available date. Leave empty to default to today.

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

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

## Actor input object example

```json
{
  "seriesCodes": [
    "IUDBEDR"
  ],
  "dateFrom": "2026-01-01",
  "dateTo": "now",
  "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 = {
    "seriesCodes": [
        "IUDBEDR"
    ],
    "dateFrom": "2026-01-01",
    "dateTo": "now",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bank-of-england-iadb-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 = {
    "seriesCodes": ["IUDBEDR"],
    "dateFrom": "2026-01-01",
    "dateTo": "now",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bank-of-england-iadb-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 '{
  "seriesCodes": [
    "IUDBEDR"
  ],
  "dateFrom": "2026-01-01",
  "dateTo": "now",
  "maxItems": 10
}' |
apify call parseforge/bank-of-england-iadb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/bank-of-england-iadb-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": "ssvjxNeaxfpFh4ZdO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~bank-of-england-iadb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-bank-of-england-iadb-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~bank-of-england-iadb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-bank-of-england-iadb-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~bank-of-england-iadb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-bank-of-england-iadb-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": {
                    "seriesCodes": {
                        "title": "Series codes",
                        "type": "array",
                        "description": "One or more Bank of England IADB series codes to pull. Each code becomes a column in the source export and one record per date and series in the output. Common codes: IUDBEDR (official Bank Rate), IUDSOIA (SONIA), IUDMNZC (10y government bond yield), IUMABEDR (monthly average Bank Rate), IUMBV34 (2y fixed 75% LTV mortgage rate), IUMTLMV (representative household interest rate), LPMVWYH and LPMAUYN (money supply M4). Find more codes on the IADB site.",
                        "default": [
                            "IUDBEDR"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Start of the date window. Accepts ISO format like 2026-01-01 or the IADB format 01/Jan/2026. Leave empty to default to one year before today."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "End of the date window. Accepts ISO format like 2026-06-01, the IADB format 01/Jun/2026, or the word 'now' for the latest available date. Leave empty to default to today."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```