# Bank of Canada Valet Scraper (`parseforge/bank-of-canada-valet-scraper`) Actor

Tap the Bank of Canada Valet API for official economic and currency series. Returns the series code, label, description, observation date, and numeric value, one row per date. Track USD CAD rates, the policy overnight rate, CPI inflation, CORRA, and Government of Canada bond yields.

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

## Pricing

from $9.00 / 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 Canada Valet Scraper

> 🚀 **Pull Canadian economic and FX data in seconds.** Turn the Bank of Canada Valet API into a clean feed of dated observations, one row per date and value.

> 🕒 **Last updated:** 2026-06-05 · **📊 7 fields** per record · multi series in a single run · daily, monthly and benchmark series

The Bank of Canada publishes its official economic and foreign exchange data through the keyless Valet API. This Actor wraps that API and returns every observation as a flat, dated row you can drop straight into a model, a dashboard, or a spreadsheet. Pick the USD/CAD daily rate, the policy overnight rate, CPI inflation, CORRA, or Government of Canada bond yields, and the Actor walks the response and emits one record per date and value.

Coverage spans the series the Bank of Canada makes public through Valet, including daily exchange rates against the US dollar, euro, pound, yen and Australian dollar, the target for the overnight rate, the bank rate, the prime rate, CORRA, the total CPI index, year over year CPI change, the CPI-median and CPI-trim core measures, and 2 year and 10 year benchmark bond yields. Add any other Valet series code by hand for full reach.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Analysts, economists, fintech builders, treasurers, researchers, data teams | FX monitoring, inflation tracking, rate watching, model inputs, dashboards, reporting |

### 📋 What the Bank of Canada Valet Scraper does

- Collects observations from one or more Bank of Canada Valet series in a single run.
- Emits one dataset row per date and value, with the series code, human label and description attached.
- Accepts a curated pick list of common series plus a free text field for any custom Valet code.
- Filters by the most recent N observations, or by a start and end date range.
- Returns clean numeric values ready for charts, models and analysis.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `seriesCodes` | array | One or more series from the curated list (FX rates, policy rate, CPI, bond yields). |
| `customSeriesCodes` | string | Any extra Valet series codes, comma separated. Added to the picked series. |
| `recent` | integer | Collect only the most recent N observations per series. Takes priority over the date range. |
| `startDate` | string | Earliest observation date, as YYYY-MM-DD. Used when Recent is empty. |
| `endDate` | string | Latest observation date, as YYYY-MM-DD. Used when Recent is empty. |
| `maxItems` | integer | Cap on the number of rows. Free plans are limited to 10. |

Example 1, recent USD/CAD and EUR/CAD daily rates:

```json
{
    "seriesCodes": ["FXUSDCAD", "FXEURCAD"],
    "recent": 10,
    "maxItems": 10
}
````

Example 2, the policy overnight rate across a date range:

```json
{
    "seriesCodes": ["V39079"],
    "startDate": "2026-01-01",
    "endDate": "2026-03-01",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** when `recent` is set it overrides the date range. Some series are daily (FX rates), others are monthly (CPI) or change only on policy decisions (overnight rate), so the number of rows per series depends on the series and the window you request.

### 📊 Output

Each record is one observation, a single date and value for one series.

| Field | Type | Description |
|---|---|---|
| 🔖 `seriesCode` | string | The Valet series code, for example FXUSDCAD. |
| 📌 `label` | string | Human readable series label, for example USD/CAD. |
| 📝 `description` | string | Full description of what the series measures. |
| 📅 `date` | string | Observation date, YYYY-MM-DD. |
| 🔢 `value` | number | The numeric value for that date. |
| 🕒 `scrapedAt` | string | When the row was collected, ISO 8601. |
| ❌ `error` | string | Null on success, a message when a run yields no data. |

Real sample records from a live run:

```json
{
  "seriesCode": "FXUSDCAD",
  "label": "USD/CAD",
  "description": "Daily average exchange rate: daily value of the US dollar expressed in Canadian dollars, for 1 unit of US dollar",
  "date": "2026-06-04",
  "value": 1.3896,
  "scrapedAt": "2026-06-05T16:29:40.339Z",
  "error": null
}
```

```json
{
  "seriesCode": "FXEURCAD",
  "label": "EUR/CAD",
  "description": "Daily average exchange rate: daily value of the euro expressed in Canadian dollars, for 1 unit of euro",
  "date": "2026-06-04",
  "value": 1.6156,
  "scrapedAt": "2026-06-05T16:29:40.397Z",
  "error": null
}
```

```json
{
  "seriesCode": "FXUSDCAD",
  "label": "USD/CAD",
  "description": "Daily average exchange rate: daily value of the US dollar expressed in Canadian dollars, for 1 unit of US dollar",
  "date": "2026-06-03",
  "value": 1.3884,
  "scrapedAt": "2026-06-05T16:29:40.417Z",
  "error": null
}
```

### ✨ Why choose this Actor

- Direct from the official Bank of Canada Valet source, no third party middleman.
- Flat one row per observation shape that loads cleanly into any tool.
- Multi series in a single run, with both labels and descriptions attached.
- Flexible windows, the most recent N points or an exact date range.
- Keyless source, no account or token needed on the data side.

### 📈 How it compares to alternatives

| Approach | Effort | Multi series | Clean dated rows |
|---|---|---|---|
| This Actor | Point and click | Yes | Yes |
| Raw Valet API calls | Manual coding | Per request | You parse it |
| Copying from web charts | Tedious | No | No |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Bank of Canada Valet Scraper and choose one or more series.
3. Set a recent count, or a start and end date, to define your window.
4. Click Start and let the run finish.
5. Open the dataset and review your dated observations.

### 💼 Business use cases

#### FX and treasury

| Need | How it helps |
|---|---|
| Currency monitoring | Track daily USD/CAD, EUR/CAD and other rates over time. |
| Hedging context | Feed official daily averages into hedging and exposure models. |

#### Macro and rates

| Need | How it helps |
|---|---|
| Rate watching | Follow the target overnight rate, bank rate, prime rate and CORRA. |
| Yield curve | Pull 2 year and 10 year Government of Canada benchmark yields. |

#### Inflation and research

| Need | How it helps |
|---|---|
| Inflation tracking | Capture total CPI, year over year change, and core CPI measures. |
| Economic research | Build clean historical panels for analysis and backtesting. |

#### Reporting and dashboards

| Need | How it helps |
|---|---|
| Recurring reports | Schedule runs to refresh a standard set of indicators. |
| Live dashboards | Push fresh dated values into BI and visualization tools. |

### 🔌 Automating Bank of Canada Valet Scraper

Connect your runs to the tools you already use:

- **Make** and **Zapier** for no code workflows.
- **Slack** alerts when a new run completes.
- **Airbyte** to load observations into a warehouse.
- **GitHub** Actions to trigger scheduled pulls.
- **Google Drive** to archive run outputs.

### 🌟 Beyond business use cases

- **Research:** assemble reproducible macro and FX datasets for papers and studies.
- **Personal:** track the loonie against your home currency over time.
- **Non-profit:** support economic literacy and public reporting projects.
- **Experimentation:** prototype forecasting models with real Canadian series.

### 🤖 Ask an AI assistant

Drop your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai) or [Copilot](https://copilot.microsoft.com) and ask it to chart trends, compute moving averages, or compare series side by side.

### ❓ Frequently Asked Questions

**Is the Bank of Canada Valet API free to use?**
Yes. Valet is a keyless public source, no account or token is required on the data side.

**Which series can I collect?**
A curated list covers common FX rates, the policy and bank rates, prime rate, CORRA, CPI measures and bond yields. You can add any other Valet series code by hand.

**Can I pull more than one series at once?**
Yes. Select several from the list and add custom codes, all are fetched in a single run.

**How do I limit how much history I get?**
Set Recent Observations to the number of latest points you want, or leave it empty and use a start and end date.

**What does each row represent?**
One observation, a single date and value for one series, with the series label and description attached.

**Are the values numeric?**
Yes. Values are parsed to numbers so they are ready for charts and models.

**Why do some series have fewer rows?**
Daily series like FX rates have a value most business days, while monthly CPI or policy rate series change far less often.

**What date format is used?**
Dates are YYYY-MM-DD, matching the source.

**How current is the data?**
The Actor returns whatever the Bank of Canada has published at run time, including the latest available dates.

**Is there a limit on rows?**
Free plans are capped at 10 rows per run. Paid plans can collect far more.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API, webhooks, or any of the supported integrations, so the data flows straight into your own systems.

### 🔗 Recommended Actors

- [DBnomics Economic Series Scraper](https://apify.com/parseforge)
- [NY Fed Reference Rates Scraper](https://apify.com/parseforge)
- [SEC XBRL Company Facts Scraper](https://apify.com/parseforge)
- [Mempool Bitcoin Scraper](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 Canada. Only publicly available data collected.

# Actor input Schema

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

Pick one or more Bank of Canada Valet series to collect. Each observation (a single date and value) becomes one row. Use Custom Series Codes below for any other series.

## `customSeriesCodes` (type: `string`):

Any Bank of Canada Valet series codes, comma separated (for example FXUSDCAD,V39079). When set, these are added to the series chosen above. Find codes at the Valet series list, https://www.bankofcanada.ca/valet/lists/series/json

## `recent` (type: `integer`):

Collect only the most recent N observations per series. Leave empty to use a date range, or to pull the full available history.

## `startDate` (type: `string`):

Earliest observation date to include, as YYYY-MM-DD. Ignored when Recent Observations is set.

## `endDate` (type: `string`):

Latest observation date to include, as YYYY-MM-DD. Ignored when Recent Observations is set.

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

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

## Actor input object example

```json
{
  "seriesCodes": [
    "FXUSDCAD",
    "FXEURCAD"
  ],
  "recent": 10,
  "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": [
        "FXUSDCAD",
        "FXEURCAD"
    ],
    "recent": 10,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bank-of-canada-valet-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": [
        "FXUSDCAD",
        "FXEURCAD",
    ],
    "recent": 10,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bank-of-canada-valet-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": [
    "FXUSDCAD",
    "FXEURCAD"
  ],
  "recent": 10,
  "maxItems": 10
}' |
apify call parseforge/bank-of-canada-valet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bank of Canada Valet Scraper",
        "description": "Tap the Bank of Canada Valet API for official economic and currency series. Returns the series code, label, description, observation date, and numeric value, one row per date. Track USD CAD rates, the policy overnight rate, CPI inflation, CORRA, and Government of Canada bond yields.",
        "version": "0.1",
        "x-build-id": "qW3bOrzOtnNc10zRV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~bank-of-canada-valet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-bank-of-canada-valet-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-canada-valet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-bank-of-canada-valet-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-canada-valet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-bank-of-canada-valet-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",
                        "type": "array",
                        "description": "Pick one or more Bank of Canada Valet series to collect. Each observation (a single date and value) becomes one row. Use Custom Series Codes below for any other series.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FXUSDCAD",
                                "FXEURCAD",
                                "FXGBPCAD",
                                "FXJPYCAD",
                                "FXAUDCAD",
                                "V39079",
                                "V122530",
                                "V80691311",
                                "AVG.INTWO",
                                "V41690973",
                                "STATIC_TOTALCPICHANGE",
                                "CPI_MEDIAN",
                                "CPI_TRIM",
                                "BD.CDN.2YR.DQ.YLD",
                                "BD.CDN.10YR.DQ.YLD"
                            ],
                            "enumTitles": [
                                "FXUSDCAD — USD/CAD daily exchange rate",
                                "FXEURCAD — EUR/CAD daily exchange rate",
                                "FXGBPCAD — GBP/CAD daily exchange rate",
                                "FXJPYCAD — JPY/CAD daily exchange rate",
                                "FXAUDCAD — AUD/CAD daily exchange rate",
                                "V39079 — Target for the overnight rate (policy rate)",
                                "V122530 — Bank rate",
                                "V80691311 — Prime rate",
                                "AVG.INTWO — CORRA overnight repo rate average",
                                "V41690973 — Total CPI index",
                                "STATIC_TOTALCPICHANGE — Total CPI, year over year percent change",
                                "CPI_MEDIAN — CPI-median core inflation",
                                "CPI_TRIM — CPI-trim core inflation",
                                "BD.CDN.2YR.DQ.YLD — 2 year Government of Canada bond yield",
                                "BD.CDN.10YR.DQ.YLD — 10 year Government of Canada bond yield"
                            ]
                        },
                        "default": [
                            "FXUSDCAD"
                        ]
                    },
                    "customSeriesCodes": {
                        "title": "Custom Series Codes",
                        "type": "string",
                        "description": "Any Bank of Canada Valet series codes, comma separated (for example FXUSDCAD,V39079). When set, these are added to the series chosen above. Find codes at the Valet series list, https://www.bankofcanada.ca/valet/lists/series/json"
                    },
                    "recent": {
                        "title": "Recent Observations",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Collect only the most recent N observations per series. Leave empty to use a date range, or to pull the full available history."
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest observation date to include, as YYYY-MM-DD. Ignored when Recent Observations is set."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest observation date to include, as YYYY-MM-DD. Ignored when Recent Observations is set."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```