# RBA Historical Statistics (`mrjerry/rba-statistics`) Actor

Fetches historical time series from the Reserve Bank of Australia's public CSV endpoints. Input an RBA table ID (f11.1 daily FX, f1.1 cash rate, a1 balance sheet) and get back uniform JSON records — one per CSV row, with date plus a name→value series dict — pushed to the default Apify Dataset.

- **URL**: https://apify.com/mrjerry/rba-statistics.md
- **Developed by:** [Huxley](https://apify.com/mrjerry) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## RBA Historical Statistics

[![Apify Store](https://img.shields.io/badge/Apify-Store-blueviolet?logo=apify)](https://apify.com/mrjerry/rba-statistics)
[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org)
[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

Fetch historical time series from the **Reserve Bank of Australia's** public CSV endpoints, in one Actor with two modes:

- **`fetch`** — pull a single RBA table and push its rows as uniform JSON records.
- **`discover`** — crawl the RBA's index page and push a list of every available CSV endpoint (slug, title, category, parent, URL).

Output records always have the same shape regardless of which table you pull, so a single downstream consumer can handle every table the RBA publishes.

```json
{
  "table": "f11.1-data",
  "source_url": "https://www.rba.gov.au/statistics/tables/csv/f11.1-data.csv",
  "fetched_at": "2026-07-09T12:35:26Z",
  "date": "2026-07-09",
  "series": {
    "A$1=USD": 0.6941,
    "Trade-weighted Index May 1970 = 100": 65.1,
    "A$1=CNY": 4.7177
  }
}
````

> **Source:** The RBA publishes ~200+ statistical tables as CSV files at predictable URLs — no auth, no rate limiting, no JS rendering. The Actor hits those URLs, parses the RBA's mixed-format CSVs (variable preamble + `01-Jan-1983` / `2026-07-08` dates), and normalises everything to ISO-8601 strings.

***

### Why use this Actor?

- **One shape, every table.** All 213 RBA CSVs emit records with the same `table / source_url / fetched_at / date / series` keys. No per-table parsing downstream.
- **Discoverable.** Don't know the slug? Run `mode: "discover"` first and the Actor returns the full index.
- **No browser, no proxy, no flakiness.** Pure `httpx` + `pandas`. Runs in seconds.
- **Bidirectional with AI agents.** The discover mode lists slugs; the fetch mode takes a slug and returns records. That's a clean tool interface for MCP / LLM use.
- **No scraping glue.** The RBA's HTML index has nested `<li>`s up to three levels deep. The Actor handles that.

***

### Quick start

```bash
## Run from the Apify CLI (you'll need an Apify account + token)
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"f11.1-data","limit":5}'

## Or invoke from Python via the Apify client
python - <<'PY'
from apify_client import ApifyClient
client = ApifyClient(token="YOUR_API_TOKEN")
run = client.actor("mrjerry/rba-statistics").call(
    run_input={"mode": "fetch", "table": "f1.1-data", "limit": 3},
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["date"], item["series"].get("Cash Rate Target"))
PY
```

***

### Modes

#### `mode: "fetch"` (default)

Pull a single RBA table. Returns one record per CSV row, sorted by date.

| Field        | Type    | Required | Default         | Description |
|--------------|---------|----------|-----------------|-------------|
| `table`      | string  | yes      | `f11.1-data`    | The RBA table slug — get these from `mode: "discover"` or the [auto-generated registry](TABLES.md). Short forms like `f11.1` are accepted and rewritten to `f11.1-data`. |
| `start_date` | string  | no       | —               | ISO `YYYY-MM-DD`; include only rows on or after this date. |
| `end_date`   | string  | no       | —               | ISO `YYYY-MM-DD`; include only rows on or before this date. |
| `limit`      | integer | no       | —               | Cap the number of records pushed (after sorting & date filtering). |
| `order`      | string  | no       | `desc`          | `desc` (latest first) or `asc` (oldest first). RBA CSVs are oldest-first by default. |

**Output record:** `{ table, source_url, fetched_at, date, series }` where `series` is a `{column_name: value}` dict for that row.

**Examples:**

```bash
## Latest 5 daily AUD/USD + TWI observations
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"f11.1-data","limit":5}'

## All exchange rates from January 2026
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"f11.1-data","start_date":"2026-01-01"}'

## Last 3 cash-rate observations
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"f1.1-data","limit":3}'

## 10 most recent RBA balance-sheet rows
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"a1-data","limit":10}'

## Oldest 5 inflation-expectation observations
apify call mrjerry/rba-statistics --input '{"mode":"fetch","table":"g3-data","limit":5,"order":"asc"}'
```

#### `mode: "discover"`

Crawl the RBA's [statistical-tables index](https://www.rba.gov.au/statistics/tables/) and push one record per available CSV.

| Field      | Type   | Required | Default | Description |
|------------|--------|----------|---------|-------------|
| `category` | string | no       | —       | Restrict results to one of the RBA's 11 H2 sections, e.g. `Interest Rates`, `Exchange Rates`, `Reserve Bank of Australia`, `Market Economists' Forecasts`. Case-insensitive. |

**Output record:** `{ slug, title, category, parent_id, url, fetched_at }` where `slug` is what you pass back into fetch mode.

**Examples:**

```bash
## All 213 tables
apify call mrjerry/rba-statistics --input '{"mode":"discover"}'

## Just the 18 interest-rate tables
apify call mrjerry/rba-statistics --input '{"mode":"discover","category":"Interest Rates"}'

## Just the 13 Market Economists' Forecasts tables
apify call mrjerry/rba-statistics --input '{"mode":"discover","category":"Market Economists\u2019 Forecasts"}'
```

The full 213-entry registry is auto-regenerated into [`TABLES.md`](TABLES.md) and [`registry.json`](registry.json) on every build.

***

### The most useful tables (curated)

The RBA publishes 213 CSVs. Here are the ones you'll reach for most often:

| Slug | What it is | Frequency | Records since |
|------|------------|-----------|---------------|
| `f1.1-data` | Cash rate target, interbank overnight, BAB/NCD, OIS | Monthly | 1969 |
| `f11.1-data` | Exchange rates — daily (TWI + ~22 bilaterals) | Daily | 2023 |
| `f1-data` | Money-market rates & yields | Daily | varies |
| `f2-data` | Capital market yields — government bonds | Daily | varies |
| `f16-data` | Indicative mid rates of Australian Government Securities | Daily | varies |
| `a1-data` | RBA balance sheet | Weekly | 1969 |
| `a2-data` | Changes in monetary policy & administered rates | As changes occur | varies |
| `a3-daily-open-market-operations` | Daily open market operations | Daily (when active) | varies |
| `a3-omo-outright-transaction-detail` | OMO outright transactions | As executed | varies |
| `d1-data` | Credit & broad money aggregates | Monthly | varies |
| `g1-data` | Consumer price inflation | Quarterly | 1922 |
| `g3-data` | Inflation expectations | Quarterly | 1993 |
| `h1-data` | GDP and gross domestic income | Quarterly | varies |
| `j1-gdp-growth` | Market economists' GDP growth forecasts | Quarterly | 1990 |
| `j1-cash-rate` | Market economists' cash-rate forecasts | As surveyed | 1990 |
| `j1-headline-inflation` | Market economists' inflation forecasts | Quarterly | 1990 |
| `j1-unemployment-rate` | Market economists' unemployment forecasts | Quarterly | 1990 |

> **Note on "records since":** the RBA trims some history from the live index. For the full long-run series (e.g. `f11.1` back to 1983, or monthly exchange rates back to 1969), use the [RBA's Historical Data page](https://www.rba.gov.au/statistics/historical-data.html) or pass the slug directly — the Actor will resolve it through the URL pattern fallback.

For the full 213-table registry, see [`TABLES.md`](TABLES.md).

***

### Categories

`discover` mode groups tables under the RBA's own 11 H2 sections:

| Category | Tables |
|---|---|
| Assets and Liabilities | 61 |
| Payments System | 33 |
| Reserve Bank of Australia | 30 |
| Household and Business Finances | 23 |
| Interest Rates | 18 |
| Money and Credit Statistics | 16 |
| Market Economists' Forecasts | 13 |
| Exchange Rates | 5 |
| Output and Labour | 5 |
| International Trade and External Finance | 5 |
| Inflation and Inflation Expectations | 4 |

***

### How the data is parsed

RBA CSVs are not standard. They start with a small preamble (table title, units, source, publication date) before the real header row. The date column is in mixed formats: older tables use `01-Jan-1983`; newer ones use `2026-07-08`. The Actor:

1. Fetches the CSV via `httpx` (60s timeout, follow redirects).
2. Scans the first 20 lines for the row whose first cell is the literal token `Title` — that's the header row.
3. Parses the rest with `pandas`, normalising the date column to `YYYY-MM-DD` strings.
4. Sorts by date (descending by default), applies date filters, then `limit`.
5. Coerces each cell to a number when possible, otherwise keeps the string. Blank cells are dropped from the `series` dict.
6. Pushes one record per row to the default Apify Dataset.

The discover mode uses `httpx` + `BeautifulSoup` to crawl the index page. It handles three different HTML shapes (leaf with title-div, leaf with bare link, container with nested `<ul>`s) and recurses up to three levels deep to find every CSV endpoint.

***

### Use as an LLM tool (MCP)

This Actor is a clean fit for an LLM agent that needs to answer questions about the Australian economy. Two tool calls work together:

1. **`discover(category: "Interest Rates")`** → the agent sees the 18 interest-rate tables and their slugs.
2. **`fetch(table: "f1.1-data", limit: 12)`** → the agent gets 12 months of cash-rate history.

You can wrap it as an MCP server with one extra Actor using the `python-mcp-empty` template, or expose it directly to Claude via [Apify's MCP integration](https://docs.apify.com/platform/integrations/mcp).

#### Prompt example

> "What has happened to the AUD/USD exchange rate over the last month?"

The agent runs `discover(category="Exchange Rates")` to find the slug, then `fetch(table="f11.1-data", start_date="<30 days ago>")` and walks the `series` dict for the `A$1=USD` key.

***

### Local development

```bash
## Install
pip install -r requirements.txt

## Run with a test input
echo '{"mode":"discover","category":"Interest Rates"}' \
    > storage/key_value_stores/default/INPUT.json
apify run

## Inspect the dataset
ls storage/datasets/default/
cat storage/datasets/default/000000001.json
```

To regenerate the full registry after the RBA adds new tables:

```bash
python -m scripts.generate_registry
## writes registry.json and TABLES.md
```

***

### Limits & gotchas

- **RBA CSVs are old.** `f11.1-data` has ~10k rows. The Actor reads the whole CSV into memory before filtering; consider `start_date` / `end_date` if you only need a slice.
- **Free plan = zero monetization.** On Apify's free tier, you pay for compute with monthly free credits. This Actor's runs are tiny (a few seconds each) but heavy users should be on a paid plan.
- **No retry on transient errors.** Single `httpx.get` with no backoff. The RBA is reliable; if you need retries, add `tenacity`.
- **Series breaks.** Some tables publish a separate `series-breaks` CSV (e.g. `b11.1-series-breaks`). The Actor doesn't merge these into the data — call them separately if you need them.

***

### License

MIT.

# Actor input Schema

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

What the Actor should do. 'fetch' (default) pulls a single RBA table and pushes its rows as JSON records. 'discover' crawls the RBA index page and pushes a list of every available CSV endpoint (slug, title, category, parent, URL) — useful for finding a table ID you don't already know.

## `table` (type: `string`):

CSV file stem from the RBA index, e.g. 'f11.1-data' (daily FX), 'f1.1-data' (cash rate), 'a1-data' (RBA balance sheet), 'a3-daily-open-market-operations'. Required when mode='fetch'. Run mode='discover' first if you don't know which one you want.

## `start_date` (type: `string`):

Optional. Include only rows on or after this date.

## `end_date` (type: `string`):

Optional. Include only rows on or before this date.

## `limit` (type: `integer`):

Optional. Cap the number of records pushed. Useful for sampling large tables like f11.1 (daily FX since 1983, ~10k rows).

## `order` (type: `string`):

Optional. 'desc' (default, latest first) or 'asc' (oldest first). RBA CSVs are oldest-first, so 'desc' gives you the most recent observations when combined with 'limit'.

## `category` (type: `string`):

Optional. Restrict discover results to one of the RBA's H2 sections, e.g. 'Interest Rates', 'Exchange Rates', 'Reserve Bank of Australia', 'Market Economists' Forecasts'. Case-insensitive. Ignored in fetch mode.

## Actor input object example

```json
{
  "mode": "fetch",
  "table": "f11.1-data",
  "order": "desc"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mrjerry/rba-statistics").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mrjerry/rba-statistics").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 '{}' |
apify call mrjerry/rba-statistics --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RBA Historical Statistics",
        "description": "Fetches historical time series from the Reserve Bank of Australia's public CSV endpoints. Input an RBA table ID (f11.1 daily FX, f1.1 cash rate, a1 balance sheet) and get back uniform JSON records — one per CSV row, with date plus a name→value series dict — pushed to the default Apify Dataset.",
        "version": "0.1",
        "x-build-id": "FxchvgvEG7rIGtbKD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mrjerry~rba-statistics/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mrjerry-rba-statistics",
                "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/mrjerry~rba-statistics/runs": {
            "post": {
                "operationId": "runs-sync-mrjerry-rba-statistics",
                "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/mrjerry~rba-statistics/run-sync": {
            "post": {
                "operationId": "run-sync-mrjerry-rba-statistics",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "fetch",
                            "discover"
                        ],
                        "type": "string",
                        "description": "What the Actor should do. 'fetch' (default) pulls a single RBA table and pushes its rows as JSON records. 'discover' crawls the RBA index page and pushes a list of every available CSV endpoint (slug, title, category, parent, URL) — useful for finding a table ID you don't already know.",
                        "default": "fetch"
                    },
                    "table": {
                        "title": "RBA table slug (fetch mode)",
                        "type": "string",
                        "description": "CSV file stem from the RBA index, e.g. 'f11.1-data' (daily FX), 'f1.1-data' (cash rate), 'a1-data' (RBA balance sheet), 'a3-daily-open-market-operations'. Required when mode='fetch'. Run mode='discover' first if you don't know which one you want.",
                        "default": "f11.1-data"
                    },
                    "start_date": {
                        "title": "Start date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional. Include only rows on or after this date."
                    },
                    "end_date": {
                        "title": "End date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional. Include only rows on or before this date."
                    },
                    "limit": {
                        "title": "Row limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional. Cap the number of records pushed. Useful for sampling large tables like f11.1 (daily FX since 1983, ~10k rows)."
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Optional. 'desc' (default, latest first) or 'asc' (oldest first). RBA CSVs are oldest-first, so 'desc' gives you the most recent observations when combined with 'limit'.",
                        "default": "desc"
                    },
                    "category": {
                        "title": "Category filter (discover mode)",
                        "type": "string",
                        "description": "Optional. Restrict discover results to one of the RBA's H2 sections, e.g. 'Interest Rates', 'Exchange Rates', 'Reserve Bank of Australia', 'Market Economists' Forecasts'. Case-insensitive. Ignored in fetch mode."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```