# OFR Short-Term Funding Monitor Scraper (`parseforge/ofr-short-term-funding-monitor-scraper`) Actor

Track repo rates, money market fund balances, and Treasury yields from the US Office of Financial Research Short-Term Funding Monitor. Every record carries a mnemonic, series name, description, observation date, and numeric value. Filter by date for funding research and rate analysis.

- **URL**: https://apify.com/parseforge/ofr-short-term-funding-monitor-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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)

## 📈 OFR Short-Term Funding Monitor Scraper

> 🚀 **Turn the OFR Short-Term Funding Monitor into clean dated rows.** Every observation becomes one record with mnemonic, series name, date, and value, ready for your model or dashboard.

> 🕒 **Last updated:** 2026-06-05 · **📊 11 fields** per record · 442 series · repo rates, money market funds, federal funds, and Treasury yields

The U.S. Office of Financial Research publishes the Short-Term Funding Monitor, a public data service that tracks money-market activity across repo, money market funds, and benchmark interest rates. This Actor reads that service and hands you back one tidy row for every observation, so a multi year rate series becomes a stack of dated rows you can chart, join, or load straight into a notebook.

Coverage spans DVP, GCF, and tri-party repo rates, money market fund investments, the effective federal funds rate, the overnight bank funding rate, and Treasury constant maturity yields. Fetch a single known series by its mnemonic, add as many extra mnemonics as you like, and narrow the window with start and end dates.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Fixed income analysts | Track repo and funding rates over time |
| Economists and researchers | Build money-market and rate panels |
| Quants and data scientists | Feed time series into models and backtests |
| Risk and treasury teams | Monitor short-term funding conditions |
| Journalists and educators | Pull official figures with full provenance |

### 📋 What the OFR Short-Term Funding Monitor Scraper does

This Actor talks to the public OFR Short-Term Funding Monitor API and returns money-market observations as flat rows. For each series it reads the full metadata and the dated value array, then emits the most recent observations first, each carrying the mnemonic, series name, description, subtype, frequency, and vintage. You can target one mnemonic from a curated list, add any number of custom mnemonics, and filter by a date range.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mnemonic` | select | A known OFR series mnemonic. Defaults to the DVP overnight/open repo rate. |
| `customMnemonics` | array | Any number of extra mnemonics to fetch alongside the selected one. |
| `maxItems` | integer | Cap on observations returned. Free plan is limited to 10. |
| `startDate` | string | Earliest observation date as YYYY-MM-DD. Optional. |
| `endDate` | string | Latest observation date as YYYY-MM-DD. Optional. |

#### Example 1, one known series

```json
{
    "mnemonic": "REPO-DVP_AR_OO-P",
    "maxItems": 50
}
````

#### Example 2, several series within a date range

```json
{
    "mnemonic": "REPO-TRI_AR_OO-P",
    "customMnemonics": ["REPO-GCF_AR_OO-P", "TYLD-TCMR-10Yr-A"],
    "startDate": "2025-01-01",
    "endDate": "2026-01-01",
    "maxItems": 300
}
```

> ⚠️ **Good to Know:** Observations are emitted newest first, and series are interleaved so a mix of mnemonics is represented under the item cap. Missing values, which the OFR uses for non-trading days or confidential periods, are skipped so every value is a usable number. Daily series can run thousands of observations, so set `maxItems` to keep runs focused.

### 📊 Output

Each record is a single observation with full series provenance.

| Field | Type | Description |
|---|---|---|
| 🔖 `mnemonic` | string | OFR series mnemonic, for example REPO-DVP\_AR\_OO-P. |
| 📌 `seriesName` | string | Human readable series name. |
| 📝 `description` | string | Full source description of what the series measures. |
| 🏷 `subtype` | string | Series subtype, for example Interest Rate. |
| 🧭 `subsetting` | string | How the series is broken out, for example Tenor. |
| ⏱ `frequency` | string | Series frequency, daily or monthly. |
| 🗂 `vintage` | string | Vintage tag such as Preliminary when the source provides one. |
| 📅 `date` | string | Observation date in YYYY-MM-DD. |
| 🔢 `value` | number | The observation value, a rate or a dollar amount. |
| 🕒 `scrapedAt` | string | ISO timestamp when the row was collected. |
| ❌ `error` | string | Null on success, message on failure. |

#### Real sample records

```json
{
    "mnemonic": "REPO-DVP_AR_OO-P",
    "seriesName": "DVP Service Average Rate: Overnight/Open (Preliminary)",
    "description": "Volume-weighted mean interest rate of overnight and open repurchase agreements in the Fixed Income Clearing Corporation's DVP Service",
    "subtype": "Interest Rate",
    "subsetting": "Tenor",
    "frequency": "Daily",
    "vintage": "Preliminary",
    "date": "2026-06-03",
    "value": 3.63,
    "scrapedAt": "2026-06-05T16:30:43.798Z",
    "error": null
}
```

```json
{
    "mnemonic": "REPO-TRI_AR_OO-P",
    "seriesName": "Tri-Party Average Rate: Overnight/Open (Preliminary)",
    "description": "Volume-weighted mean interest rate of overnight and open repurchase agreements that were settled in tri-party repo",
    "subtype": "Interest Rate",
    "subsetting": "Tenor",
    "frequency": "Daily",
    "vintage": "Preliminary",
    "date": "2026-06-02",
    "value": 3.62,
    "scrapedAt": "2026-06-05T16:30:43.856Z",
    "error": null
}
```

```json
{
    "mnemonic": "TYLD-TCMR-10Yr-A",
    "seriesName": "10-Year Treasury Constant Maturity Rate",
    "description": "10-Year Treasury Constant Maturity Rate. Yields are interpolated by the Treasury from the daily yield curve.",
    "subtype": "Interest Rate",
    "subsetting": "None",
    "frequency": "Daily",
    "vintage": "",
    "date": "2026-06-03",
    "value": 4.49,
    "scrapedAt": "2026-06-05T16:30:43.936Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One row per observation, no nested arrays to unpack.
- Full provenance on every row, so you always know the series and what it measures.
- Works keyless against the public OFR API, no account or token to manage on the source side.
- Curated list of known mnemonics plus open custom input for any series.
- Clean numeric values with plain dates, ready for charts and models.

### 📈 How it compares to alternatives

| Approach | Provenance per row | Date filtering | Setup effort |
|---|---|---|---|
| This Actor | Yes, series metadata included | Yes, start and end dates | Pick a mnemonic and run |
| Manual API calls | You build it yourself | You build it yourself | Write and maintain code |
| Spreadsheet downloads | Often lost | Manual | Manual and repetitive |

### 🚀 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 OFR Short-Term Funding Monitor Scraper in the Apify Console.
3. Pick a mnemonic from the dropdown and add any custom mnemonics you want.
4. Set `maxItems` and an optional `startDate` and `endDate`, then click Start.
5. Watch the run finish and open the results to view or pull your observations.

### 💼 Business use cases

#### Funding and rates research

| Goal | How this helps |
|---|---|
| Track repo conditions | Pull DVP, GCF, and tri-party rates into one table |
| Compare benchmarks | Collect federal funds and Treasury yields side by side |

#### Quant and modeling

| Goal | How this helps |
|---|---|
| Feature engineering | Turn long history series into dated training rows |
| Backtesting | Align observations by date across series |

#### Risk and treasury

| Goal | How this helps |
|---|---|
| Liquidity monitoring | Follow money market fund balances over time |
| Stress signals | Watch short-term rate moves around quarter ends |

#### Content and education

| Goal | How this helps |
|---|---|
| Data journalism | Cite official figures with series names and dates |
| Teaching | Hand students clean, sourced money-market series |

### 🔌 Automating OFR Short-Term Funding Monitor Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub, or Google Drive through the Apify integrations. Schedule a daily run to refresh a repo rate panel, post new observations to a Slack channel, or sync results into a Google Sheet for a live dashboard.

### 🌟 Beyond business use cases

- **Research:** assemble reproducible money-market datasets with full provenance for papers.
- **Personal:** track the funding rates you care about in a private dashboard.
- **Non-profit:** monitor public financial-stability indicators from a government source.
- **Experimentation:** prototype rate models without writing API plumbing.

### 🤖 Ask an AI assistant

Drop 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 summarize trends, compute spreads between rates, or compare series across tenors.

### ❓ Frequently Asked Questions

**What is the OFR Short-Term Funding Monitor?**
It is a public data service from the U.S. Office of Financial Research that tracks money-market activity, including repo rates, money market funds, and benchmark interest rates.

**Do I need an API key or account on the OFR?**
No. The OFR API is public and keyless. You only need an Apify account to run this Actor.

**How do I find a mnemonic?**
Browse the OFR series catalog at data.financialresearch.gov, or pick one from the dropdown. Mnemonics look like REPO-DVP\_AR\_OO-P or TYLD-TCMR-10Yr-A.

**Can I fetch more than one series at once?**
Yes. Pick one in the dropdown and add any number of extra mnemonics in the custom field. They are fetched together.

**How does the date filter work?**
Set `startDate` and `endDate` as YYYY-MM-DD. Only observations within that range are returned. Leave them empty for full history.

**In what order are observations returned?**
Newest first within each series, and series are interleaved so a mix of mnemonics is represented under the item cap.

**How many observations can I get?**
Free plans return up to 10. Paid plans can return up to 1,000,000 per run.

**Why are some dates missing from a series?**
The OFR records missing values for non-trading days or periods where data is withheld to protect confidential information. Those entries are skipped so every value is usable.

**What does the value field represent?**
A rate in percent for interest rate series, or a dollar amount for money market fund balances, depending on the series.

**What is a vintage?**
Some series carry a tag like Preliminary that marks the data revision stage. The field appears when the source provides one.

**Which families of series are covered?**
DVP, GCF, and tri-party repo, money market funds, federal funds and overnight bank funding rates, and Treasury constant maturity yields, among others, across more than 400 mnemonics.

**Is the value always numeric?**
Yes. Missing and non numeric entries are skipped so every value is a usable number.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and scheduler to wire results into your own stack, or trigger downstream jobs whenever a run completes.

### 🔗 Recommended Actors

- [DBnomics Economic Series Scraper by ParseForge](https://apify.com/parseforge)
- [Bank of Canada Valet Scraper by ParseForge](https://apify.com/parseforge)
- [World Bank Indicators Scraper by ParseForge](https://apify.com/parseforge)
- [Treasury Yield Curve Scraper by ParseForge](https://apify.com/parseforge)
- [Currency Exchange Rates Scraper by ParseForge](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 U.S. Office of Financial Research or the U.S. Treasury. Only publicly available data is collected.

# Actor input Schema

## `mnemonic` (type: `string`):

An OFR Short-Term Funding Monitor series to fetch. Pick one from the list, or add more in Custom Mnemonics below. Each dated observation becomes one record.

## `customMnemonics` (type: `array`):

Add any number of OFR series mnemonics (for example REPO-GCF\_AR\_TOT-P or TYLD-TCMR-30Yr-A). These are fetched in addition to the series selected above. Find codes in the OFR series catalog at data.financialresearch.gov.

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

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

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

Earliest observation date to include, as YYYY-MM-DD. Leave empty to include all available history.

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

Latest observation date to include, as YYYY-MM-DD. Leave empty to include up to the most recent observation.

## Actor input object example

```json
{
  "mnemonic": "REPO-DVP_AR_OO-P",
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ofr-short-term-funding-monitor-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ofr-short-term-funding-monitor-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 '{
  "maxItems": 10
}' |
apify call parseforge/ofr-short-term-funding-monitor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OFR Short-Term Funding Monitor Scraper",
        "description": "Track repo rates, money market fund balances, and Treasury yields from the US Office of Financial Research Short-Term Funding Monitor. Every record carries a mnemonic, series name, description, observation date, and numeric value. Filter by date for funding research and rate analysis.",
        "version": "0.1",
        "x-build-id": "kjTgiL9LGwe0RlppC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ofr-short-term-funding-monitor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ofr-short-term-funding-monitor-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~ofr-short-term-funding-monitor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ofr-short-term-funding-monitor-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~ofr-short-term-funding-monitor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ofr-short-term-funding-monitor-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": {
                    "mnemonic": {
                        "title": "Series Mnemonic",
                        "enum": [
                            "REPO-DVP_AR_OO-P",
                            "REPO-DVP_AR_TOT-P",
                            "REPO-GCF_AR_OO-P",
                            "REPO-TRI_AR_OO-P",
                            "REPO-TRI_AR_TOT-P",
                            "MMF-MMF_TOT-M",
                            "FNYR-EFFR-A",
                            "FNYR-OBFR-A",
                            "TYLD-TCMR-3Mo-A",
                            "TYLD-TCMR-2Yr-A",
                            "TYLD-TCMR-10Yr-A"
                        ],
                        "type": "string",
                        "description": "An OFR Short-Term Funding Monitor series to fetch. Pick one from the list, or add more in Custom Mnemonics below. Each dated observation becomes one record.",
                        "default": "REPO-DVP_AR_OO-P"
                    },
                    "customMnemonics": {
                        "title": "Custom Mnemonics",
                        "type": "array",
                        "description": "Add any number of OFR series mnemonics (for example REPO-GCF_AR_TOT-P or TYLD-TCMR-30Yr-A). These are fetched in addition to the series selected above. Find codes in the OFR series catalog at data.financialresearch.gov.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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"
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest observation date to include, as YYYY-MM-DD. Leave empty to include all available history."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest observation date to include, as YYYY-MM-DD. Leave empty to include up to the most recent observation."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
