# NY Fed Reference Rates Scraper (`parseforge/nyfed-reference-rates-scraper`) Actor

Track the U.S. dollar benchmarks straight from the Federal Reserve Bank of New York. Pull SOFR, EFFR, OBFR, TGCR, and BGCR with effective date, percent rate, volume in billions, and percentile spread. Handy for treasury teams, rates traders, and funding market research.

- **URL**: https://apify.com/parseforge/nyfed-reference-rates-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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)

## 🏦 NY Fed Reference Rates Scraper

> 🚀 **Pull the benchmark rates that price trillions in dollar funding.** Get SOFR, EFFR, OBFR, TGCR, and BGCR straight from the Federal Reserve Bank of New York, with rate, volume, and the full percentile distribution for each day.

> 🕒 **Last updated:** 2026-06-04 · **📊 19 fields** per record · 5 core reference rates plus the SOFR Averages and Index · official NY Fed Markets data

The Federal Reserve Bank of New York publishes the U.S. dollar reference rates that anchor floating rate loans, derivatives, and money market instruments. This Actor reads those rates directly from the NY Fed Markets API and returns one clean record per rate. You get the latest published value for every benchmark, or the recent daily history of a single rate, with no API key and no account required at the source.

Coverage spans the secured rates (SOFR, the Tri-Party General Collateral Rate, and the Broad General Collateral Rate), the unsecured rates (the Effective Federal Funds Rate and the Overnight Bank Funding Rate), and the SOFR Averages and Index used in many loan contracts. Each record carries the effective date, the published rate, the trading volume in billions of dollars, and the 1st, 25th, 75th, and 99th percentiles of the underlying transactions.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Quant analysts and rates traders | Track SOFR and fed funds daily |
| Treasury and corporate finance teams | Reset floating rate loans and swaps |
| Fintech and lending platforms | Feed benchmark rates into pricing engines |
| Economists and researchers | Study funding markets and rate spreads |
| Risk and compliance teams | Document the rates used in valuations |

### 📋 What the NY Fed Reference Rates Scraper does

This Actor connects to the Federal Reserve Bank of New York Markets API and collects published reference rate observations. It runs in two modes, both auto-detected from your input:

- **Latest rates** returns the most recent published value for a group of benchmarks. Choose all rates, secured rates only, or unsecured rates only.
- **Single rate history** returns the recent daily observations for one rate type, for example the last 30 days of SOFR.

Every observation is normalized into a flat record with a human readable rate name, the effective date, the rate, the volume, and the percentile distribution. Rates that carry extra context, such as the federal funds target range on EFFR or the 30, 90, and 180 day averages on the SOFR Averages and Index, include those values too.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `rateGroup` | select | Which group of latest rates to pull. All, secured, or unsecured. Default all. |
| `rateType` | select | Pick one rate type to pull its recent daily history instead of the latest snapshot. |
| `historyDays` | integer | How many recent daily observations to return in history mode. Default 30. |
| `maxItems` | integer | Cap on records returned. Free plans are limited to 10. |

**Example 1. Latest value for every reference rate**

```json
{
  "rateGroup": "all",
  "maxItems": 10
}
````

**Example 2. Last 30 days of SOFR**

```json
{
  "rateType": "SOFR",
  "historyDays": 30,
  "maxItems": 30
}
```

> ⚠️ **Good to Know:** When you select a `rateType`, the Actor switches to history mode and the `rateGroup` value is ignored. The SOFR Averages and Index record (type SOFRAI) reports compounded averages and an index level rather than a daily percent rate, so its `percentRate`, percentile, and volume fields stay empty by design.

### 📊 Output

Each record contains these fields:

| Field | Description |
|---|---|
| 🏷 `type` | Rate code, for example SOFR, EFFR, OBFR, TGCR, BGCR, SOFRAI |
| 📌 `rateName` | Human readable name of the rate |
| 📅 `effectiveDate` | Date the rate applies to |
| 📈 `percentRate` | Published rate as a percent |
| 💵 `volumeInBillions` | Underlying transaction volume in billions of dollars |
| 📉 `percentPercentile1` | 1st percentile of the rate distribution |
| 📊 `percentPercentile25` | 25th percentile of the rate distribution |
| 📊 `percentPercentile75` | 75th percentile of the rate distribution |
| 📈 `percentPercentile99` | 99th percentile of the rate distribution |
| 🎯 `targetRateFrom` | Lower bound of the fed funds target range (EFFR) |
| 🎯 `targetRateTo` | Upper bound of the fed funds target range (EFFR) |
| 📐 `average30day` | 30 day compounded SOFR average (SOFRAI) |
| 📐 `average90day` | 90 day compounded SOFR average (SOFRAI) |
| 📐 `average180day` | 180 day compounded SOFR average (SOFRAI) |
| 🧮 `index` | SOFR index level (SOFRAI) |
| 🔖 `revisionIndicator` | Marks a revised observation when present |
| 🔗 `sourceUrl` | NY Fed API endpoint the record came from |
| 🕒 `scrapedAt` | Timestamp when the record was collected |
| ❌ `error` | Null on success, message on failure |

**Real sample records**

```json
{
  "type": "SOFR",
  "rateName": "Secured Overnight Financing Rate",
  "effectiveDate": "2026-06-03",
  "percentRate": 3.61,
  "volumeInBillions": 3098,
  "percentPercentile1": 3.58,
  "percentPercentile25": 3.59,
  "percentPercentile75": 3.67,
  "percentPercentile99": 3.7,
  "targetRateFrom": null,
  "targetRateTo": null,
  "average30day": null,
  "average90day": null,
  "average180day": null,
  "index": null,
  "revisionIndicator": "",
  "sourceUrl": "https://markets.newyorkfed.org/api/rates/all/latest.json",
  "scrapedAt": "2026-06-04T20:16:44.302Z",
  "error": null
}
```

```json
{
  "type": "EFFR",
  "rateName": "Effective Federal Funds Rate",
  "effectiveDate": "2026-06-03",
  "percentRate": 3.62,
  "volumeInBillions": 119,
  "percentPercentile1": 3.6,
  "percentPercentile25": 3.62,
  "percentPercentile75": 3.63,
  "percentPercentile99": 3.69,
  "targetRateFrom": 3.5,
  "targetRateTo": 3.75,
  "average30day": null,
  "average90day": null,
  "average180day": null,
  "index": null,
  "revisionIndicator": "",
  "sourceUrl": "https://markets.newyorkfed.org/api/rates/all/latest.json",
  "scrapedAt": "2026-06-04T20:16:44.127Z",
  "error": null
}
```

```json
{
  "type": "SOFRAI",
  "rateName": "SOFR Averages and Index",
  "effectiveDate": "2026-06-04",
  "percentRate": null,
  "volumeInBillions": null,
  "percentPercentile1": null,
  "percentPercentile25": null,
  "percentPercentile75": null,
  "percentPercentile99": null,
  "targetRateFrom": null,
  "targetRateTo": null,
  "average30day": 3.58967,
  "average90day": 3.63898,
  "average180day": 3.68981,
  "index": 1.24583579,
  "revisionIndicator": "",
  "sourceUrl": "https://markets.newyorkfed.org/api/rates/all/latest.json",
  "scrapedAt": "2026-06-04T20:16:44.007Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Straight from the source.** Data comes from the Federal Reserve Bank of New York Markets API, the official publisher of these rates.
- **Full distribution, not just a headline number.** Every rate ships with its volume and four percentile points, so you see the shape of the market.
- **Two modes, one Actor.** Snapshot the whole benchmark set or drill into the daily history of a single rate.
- **No source key needed.** The NY Fed endpoints are public, so there is nothing to register for at the data source.
- **Clean, flat records.** Consistent field names across every rate type make the output ready for a spreadsheet, a database, or a model.

### 📈 How it compares to alternatives

| Approach | Setup | Distribution data | History mode | Maintained |
|---|---|---|---|---|
| This Actor | None at the source | Volume plus four percentiles | Yes | Yes |
| Manual page checks | Copy and paste daily | Often skipped | Tedious | Manual |
| Generic HTTP scripts | Build and host yourself | You parse it | You build it | You maintain it |

### 🚀 How to use

1. **Sign up.** Create a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. **Open the Actor.** Go to the NY Fed Reference Rates Scraper in the Apify Console.
3. **Set your input.** Choose a rate group for the latest snapshot, or pick a single rate type and a number of history days.
4. **Run it.** Click Start and watch the records arrive in the run log.
5. **Collect the data.** Open the dataset tab to view or pull the results through the API.

### 💼 Business use cases

#### Treasury and lending

| Need | How this Actor helps |
|---|---|
| Reset floating rate loans | Pull the current SOFR or its averages on schedule |
| Price new facilities | Read the latest benchmark and target range together |

#### Trading and analytics

| Need | How this Actor helps |
|---|---|
| Monitor funding stress | Track the spread between SOFR and EFFR daily |
| Backtest rate models | Pull recent daily history for a single rate |

#### Risk and valuation

| Need | How this Actor helps |
|---|---|
| Document discount rates | Capture the rate and percentile spread used in a valuation |
| Validate vendor feeds | Cross check a third party number against the source |

#### Reporting and dashboards

| Need | How this Actor helps |
|---|---|
| Build a rates dashboard | Feed a tidy daily snapshot into your charts |
| Brief stakeholders | Summarize where overnight funding rates sit today |

### 🔌 Automating NY Fed Reference Rates Scraper

Connect the Actor to the tools your team already runs:

- **Make.** Trigger a scenario each time a run finishes and route records onward.
- **Zapier.** Send fresh rates into a sheet or a CRM step.
- **Slack.** Post the morning SOFR and EFFR to a channel.
- **Airbyte.** Sync the dataset into your warehouse.
- **GitHub.** Schedule runs from a workflow and commit snapshots.
- **Google Drive.** Drop daily exports into a shared folder.

### 🌟 Beyond business use cases

- **Research.** Study the behavior of secured and unsecured funding markets over time.
- **Personal finance.** Follow the benchmark behind adjustable rate products you hold.
- **Non-profit.** Add transparent, official rate data to public interest reports.
- **Experimentation.** Prototype a rates model or a teaching example with real numbers.

### 🤖 Ask an AI assistant

Paste a few records into your favorite assistant and ask for help:

- **ChatGPT.** Summarize the spread between SOFR and EFFR today.
- **Claude.** Explain what a rising 99th percentile on SOFR might signal.
- **Perplexity.** Compare the current fed funds target range with the effective rate.
- **Copilot.** Draft a script that charts a week of SOFR history.

### ❓ Frequently Asked Questions

**Which rates does the Actor cover?**
SOFR, the Tri-Party General Collateral Rate (TGCR), the Broad General Collateral Rate (BGCR), the Effective Federal Funds Rate (EFFR), the Overnight Bank Funding Rate (OBFR), and the SOFR Averages and Index.

**Where does the data come from?**
The Federal Reserve Bank of New York Markets API, the official publisher of these reference rates.

**Do I need an API key for the source?**
No. The NY Fed endpoints are public and require no key or registration at the source.

**What is the difference between the two modes?**
Leave `rateType` empty to get the latest published value for a group of rates. Set `rateType` to one benchmark to get its recent daily history instead.

**How far back can the history go?**
The Actor requests the most recent observations for a single rate. Set `historyDays` to choose how many to return.

**Why are some fields empty on certain rows?**
Each rate type reports a different set of values. The SOFR Averages and Index row carries compounded averages and an index level rather than a daily percent rate, while EFFR adds the fed funds target range. Fields that do not apply to a given row stay empty.

**What does volumeInBillions mean?**
It is the dollar volume of the transactions that produced the rate, expressed in billions.

**What are the percentile fields?**
They describe the distribution of the underlying transactions, from the 1st through the 99th percentile, so you can see how tight or wide the market traded.

**How current is the data?**
The Actor returns the latest values the NY Fed has published at the moment you run it. Rates are published on business days.

**What does revisionIndicator tell me?**
When the NY Fed revises a previously published observation, this field marks it. It is empty for standard observations.

**Can I track several rates at once?**
Yes. The default latest mode returns every benchmark in a single run.

**How many records can I get on a free plan?**
Free plans return up to 10 records per run. Paid plans raise that limit.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API or connect to Make, Zapier, and other platforms. Schedule the Actor to keep a rolling record of daily rates with no manual work.

### 🔗 Recommended Actors

- [FRED Scraper](https://apify.com/parseforge/fred-scraper). Federal Reserve Economic Data series for thousands of economic indicators.
- [Federal Reserve H.15 Rates Scraper](https://apify.com/parseforge/federalreserve-h15-rates-scraper). The Fed H.15 selected interest rates release.
- [ECB FX Rates Scraper](https://apify.com/parseforge/ecb-fx-rates-scraper). European Central Bank euro foreign exchange reference rates.
- [SNB Swiss Rates Scraper](https://apify.com/parseforge/snb-swiss-rates-scraper). Swiss National Bank policy and money market rates.
- [US Treasury Fiscal Data Scraper](https://apify.com/parseforge/us-treasury-fiscal-data-scraper). Treasury fiscal datasets including rates and balances.

> 💡 **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 Federal Reserve Bank of New York. Only publicly available data is collected.

# Actor input Schema

## `rateGroup` (type: `string`):

Which group of latest reference rates to pull. All returns SOFR, TGCR, BGCR, EFFR, OBFR and the SOFR Averages and Index. Secured returns SOFR, TGCR, BGCR. Unsecured returns EFFR, OBFR. Ignored when a specific rate type is selected below.

## `rateType` (type: `string`):

Select one rate type to pull its recent daily history instead of the latest snapshot. Leave empty to use the latest rates mode above.

## `historyDays` (type: `integer`):

How many of the most recent daily observations to pull when a single rate type is selected above. Ignored in latest rates mode.

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

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

## Actor input object example

```json
{
  "rateGroup": "all",
  "rateType": "",
  "historyDays": 30,
  "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 = {
    "historyDays": 30,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nyfed-reference-rates-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 = {
    "historyDays": 30,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nyfed-reference-rates-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 '{
  "historyDays": 30,
  "maxItems": 10
}' |
apify call parseforge/nyfed-reference-rates-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NY Fed Reference Rates Scraper",
        "description": "Track the U.S. dollar benchmarks straight from the Federal Reserve Bank of New York. Pull SOFR, EFFR, OBFR, TGCR, and BGCR with effective date, percent rate, volume in billions, and percentile spread. Handy for treasury teams, rates traders, and funding market research.",
        "version": "0.1",
        "x-build-id": "dlnU9puy8uzBsujXO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nyfed-reference-rates-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nyfed-reference-rates-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~nyfed-reference-rates-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nyfed-reference-rates-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~nyfed-reference-rates-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nyfed-reference-rates-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": {
                    "rateGroup": {
                        "title": "Rate group (latest mode)",
                        "enum": [
                            "all",
                            "secured",
                            "unsecured"
                        ],
                        "type": "string",
                        "description": "Which group of latest reference rates to pull. All returns SOFR, TGCR, BGCR, EFFR, OBFR and the SOFR Averages and Index. Secured returns SOFR, TGCR, BGCR. Unsecured returns EFFR, OBFR. Ignored when a specific rate type is selected below.",
                        "default": "all"
                    },
                    "rateType": {
                        "title": "Single rate type (history mode)",
                        "enum": [
                            "",
                            "SOFR",
                            "TGCR",
                            "BGCR",
                            "EFFR",
                            "OBFR"
                        ],
                        "type": "string",
                        "description": "Select one rate type to pull its recent daily history instead of the latest snapshot. Leave empty to use the latest rates mode above.",
                        "default": ""
                    },
                    "historyDays": {
                        "title": "History length",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many of the most recent daily observations to pull when a single rate type is selected above. Ignored in latest rates mode."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
