# 💵 US Treasury Yields & Bond Data — Curve, 2s10s, Spreads (`nexgendata/treasury-yields-bonds`) Actor

Track US Treasury yield curve from 1M to 30Y — daily yields, spreads, 2s10s curve inversion, historical changes. FRED + Treasury.gov public data for fixed income desks, asset allocators, macro hedge funds, treasury teams. Bloomberg yield curve alternative, no terminal needed. Pay-per-result.

- **URL**: https://apify.com/nexgendata/treasury-yields-bonds.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 yield records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 💵 US Treasury Yields & Bond Data — Curve, 2s10s, Spreads

**The Bloomberg yield curve, without the Bloomberg terminal.** Daily US Treasury constant‑maturity yields from 1‑Month to 30‑Year, sourced live from FRED (Federal Reserve Bank of St. Louis) and the U.S. Treasury Department — packaged with rolling 1‑day / 1‑week / 1‑month / year‑to‑date change context, curve‑segment tags (short / belly / long), the 2s10s spread, and an `inverted` flag so you can wire curve‑inversion alerts straight into your pipeline.

### 📊 Sample Output

[![💵 US Treasury Yields & Bond Data — Curve, 2s10s, Spreads sample output — 💵 US Treasury Yields & Bond Data — Curve, 2s10s, Spreads, premium API, JSON output, NexGenData premium dataset for analysts, he](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/treasury-yields-bonds-output.png)](https://apify.com/nexgendata/treasury-yields-bonds)

If you trade rates, allocate across asset classes, run a corporate treasury, manage pension liabilities, or build macro dashboards, this actor is your low‑cost, programmatic alternative to Bloomberg `<GC>`, Refinitiv Eikon, FactSet, or scraping Treasury.gov yourself.

---

### Who this is for

- **Fixed‑income desks** — daily mark‑to‑market against the official Treasury constant‑maturity curve, plus pre‑computed yield‑change deltas in basis points.
- **Asset allocators & macro hedge funds** — 2s10s, curve‑segment exposure, inversion signal — all in one row.
- **Pension funds and LDI teams** — long‑end yields (20Y / 30Y) for liability discounting, no terminal seat required.
- **Corporate treasury teams** — benchmark rates for floating‑rate debt, intercompany loans, and discount‑rate disclosures.
- **Quant researchers / academics** — full daily history per tenor, programmatic access, deterministic schema.
- **AI / agent builders** — drop the dataset into an MCP server, RAG store, or scheduled Slack digest.

---

### What you get — schema

Every row in the dataset has the following fields:

| Field | Type | Example | Meaning |
|---|---|---|---|
| `instrument` | string | `US Treasury 10-Year Constant Maturity` | Friendly instrument name. |
| `tenor` | string | `10Y` | Standard tenor label (1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y, 20Y, 30Y). |
| `tenor_years` | number | `10.0` | Tenor expressed in years (fractions for 1M/3M/6M). |
| `yield_pct` | number | `4.38` | Annualized yield, percent. |
| `as_of_date` | string | `2026-05-08` | Observation date (ISO‑8601). |
| `price` | number / null | `null` | Clean price when available — FRED publishes yields, so this is null for constant‑maturity series. |
| `change_bps_1d` | number / null | `-3.0` | Change vs. prior business day, in basis points. |
| `change_bps_1w` | number / null | `+8.0` | Change vs. one week prior. |
| `change_bps_1m` | number / null | `+12.0` | Change vs. one month prior. |
| `change_bps_ytd` | number / null | `+47.0` | Change vs. the first observation of the current year. |
| `series_id` | string | `DGS10` | Underlying FRED series identifier. |
| `curve_segment` | string | `long` | One of `short` (≤1Y), `belly` (2Y–7Y), `long` (10Y+). |
| `2s10s_spread_bps` | number | `48.0` | The classic 2s10s spread, in bps, sampled on the same observation date. |
| `inverted` | boolean | `false` | `true` when 2Y > 10Y (curve inverted). |
| `data_source` | string | `FRED (St. Louis Fed) — Treasury Constant Maturity` | Provenance string. |

---

### Input

```json
{
  "tenors": ["2Y", "5Y", "10Y", "30Y"],
  "date_range": "today",
  "include_historical": false
}
````

| Input | Type | Default | Notes |
|---|---|---|---|
| `tenors` | array of strings | full curve | Subset of `1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y, 20Y, 30Y`. |
| `date_range` | enum | `today` | `today`, `last_30d`, `last_90d`, `ytd`. |
| `include_historical` | boolean | `false` | When `true`, emits one row per `(tenor, date)` for the date range. |

The actor **always** pulls 2Y and 10Y internally so the 2s10s spread and inversion flag are populated even when you ask for a narrower tenor list.

***

### Example outputs

**Latest 10Y row (today):**

```json
{
  "instrument": "US Treasury 10-Year Constant Maturity",
  "tenor": "10Y",
  "tenor_years": 10.0,
  "yield_pct": 4.38,
  "as_of_date": "2026-05-08",
  "price": null,
  "change_bps_1d": -3.0,
  "change_bps_1w": -1.0,
  "change_bps_1m": +8.0,
  "change_bps_ytd": +12.0,
  "series_id": "DGS10",
  "curve_segment": "long",
  "2s10s_spread_bps": 48.0,
  "inverted": false,
  "data_source": "FRED (St. Louis Fed) — Treasury Constant Maturity"
}
```

**2Y row from the same run:**

```json
{
  "instrument": "US Treasury 2-Year Constant Maturity",
  "tenor": "2Y",
  "yield_pct": 3.90,
  "2s10s_spread_bps": 48.0,
  "inverted": false,
  "curve_segment": "belly"
}
```

***

### Why this exists — Bloomberg / FactSet / Refinitiv alternative

| Platform | Cost / month | API access | Yield curve history | Curve‑inversion signal | Setup time |
|---|---|---|---|---|---|
| **Bloomberg Terminal** | ~$2,000 | Limited (BBG‑native) | Yes | Manual | Days |
| **Refinitiv Eikon / LSEG** | ~$1,800 | Yes (paid add‑on) | Yes | Manual | Days |
| **FactSet** | ~$1,500+ | Yes (paid) | Yes | Manual | Days |
| **TradingEconomics API** | $99–$999 | Yes | Limited | No | Hours |
| **DIY Treasury.gov scrape** | Free | Build it yourself | Yes (CSV) | Build it yourself | Weeks |
| **💵 NexGenData Treasury Yields actor** | **Pay‑per‑result** | **JSON / CSV / Excel / RSS** | **Full daily history** | **Built in** | **Minutes** |

You're not paying for the data — FRED and Treasury.gov are public — you're paying for the assembled curve: deltas, segments, spread, inversion flag, deterministic schema, and the dataset surface that snaps into Apify integrations (Webhooks, Zapier, Make, Google Sheets, n8n, MCP).

***

### How it works under the hood

1. **Probe FRED for each tenor.** For every tenor in scope (and always 2Y + 10Y for spread context), the actor hits `https://fred.stlouisfed.org/graph/fredgraph.csv?id={SERIES}` and parses the CSV. No API key required for daily series.
2. **Normalize the curve.** Missing observations (FRED publishes `.` for non‑business days) are skipped. The reference "today" is the most recent observation across the fetched series, so weekend/holiday runs still return the last good print.
3. **Compute deltas.** For each emitted point we look up the most recent value on or before T‑1, T‑7, T‑30, and the first observation of the calendar year. All deltas are expressed in basis points (rounded to 0.01 bp).
4. **Tag and spread.** Tenor is bucketed into `short` / `belly` / `long`. The 2Y vs 10Y spread is computed in bps; `inverted = true` when 2Y > 10Y.
5. **Push to dataset.** One JSON record per (tenor, observation date). Stream to your warehouse or hit `/dataset/items?format=csv` for Excel.

Fallback: when FRED is unreachable, the actor logs a warning per series and emits whatever it has. No silent failure.

***

### Curve‑inversion playbook

The 2s10s spread has front‑run every U.S. recession since the 1960s. With this dataset you can:

- Schedule the actor daily (Apify schedules → cron) and emit a Webhook when `inverted` flips.
- Plot the term structure (yield\_pct vs tenor\_years) in any BI tool.
- Cross‑reference `change_bps_1d` with risk‑asset moves (SPY, HYG) to spot bear flatteners vs bull steepeners.
- Combine with our **ETF Holdings Tracker** to monitor TLT/IEF/SHY positioning while the curve moves.

***

### Pricing

Pay‑per‑event:

- **Actor start:** $0.01 (charged once when the actor begins running).
- **Yield record:** $0.10 per Treasury yield record returned (tenor, yield, daily / weekly / monthly / YTD deltas, curve context).

A full curve snapshot (11 tenors, `date_range=today`) costs **$0.01 + 11 × $0.10 = $1.11**. A subset of 4 key tenors costs **$0.41**. A `ytd` historical pull of one tenor (~100 trading days) costs roughly **$10**.

Margins are 20%. Pricing kicks in 14 days after publication for existing users — fresh runs in the first two weeks are free for trial.

***

### Sister actors from NexGenData

This actor is part of the NexGenData cross‑asset intelligence fleet. Pair it with:

- **[nexgendata/finance-mcp-server](https://apify.com/nexgendata/finance-mcp-server)** — MCP server that exposes the full NexGenData finance fleet to Claude, ChatGPT, and any MCP‑aware agent.
- **[nexgendata/etf-holdings-tracker](https://apify.com/nexgendata/etf-holdings-tracker)** — bond ETF (TLT, IEF, SHY, AGG, LQD, HYG) and equity ETF holdings — overlap analysis when the curve moves.
- **[nexgendata/finviz-stock-screener](https://apify.com/nexgendata/finviz-stock-screener)** — screen equities by valuation, growth, and technicals to pair with macro rate calls.
- **[nexgendata/sec-form-13f-holdings-tracker](https://apify.com/nexgendata/sec-form-13f-holdings-tracker)** — quarterly institutional positioning, including duration bets via Treasury‑futures and rate‑sensitive equities.
- **[nexgendata/chinese-adrs-stock-screener](https://apify.com/nexgendata/chinese-adrs-stock-screener)** — China ADR screener for rate‑sensitive EM exposure.
- **[nexgendata/earnings-calendar](https://apify.com/nexgendata/earnings-calendar)** — earnings calendar overlay for event‑driven rates trades.

***

### Integration recipes

**Daily Slack digest** — set a daily schedule, route the dataset to a Make.com / Zapier scenario that posts the full curve plus the 2s10s line to a Slack channel.

**Curve‑inversion alert** — schedule daily; webhook fires only when `inverted = true` and `change_bps_1d` magnitudes exceed your threshold.

**LDI rebalance feed** — pipe the 20Y/30Y rows into your liability‑discounting model via the Apify Google Sheets integration.

**MCP / agent** — wire this actor into the [finance‑mcp‑server](https://apify.com/nexgendata/finance-mcp-server) so an LLM agent can ask "what's the 2s10s today" and get a typed answer.

**Backtesting** — set `date_range=ytd` and `include_historical=true` to get the full year per tenor, then materialize into Parquet via the Apify Dataset API.

***

### FAQ

**Q: Is this real‑time?**
A: FRED publishes Treasury constant‑maturity yields with a 1‑business‑day lag. For intraday quotes use a paid market‑data feed; for end‑of‑day analytics this dataset matches the Fed's official release.

**Q: Why FRED and not Treasury.gov directly?**
A: Both work. FRED is more programmatic (clean CSV per series), versus the Treasury XML which changes layout. We use FRED's `Treasury Constant Maturity` series — the same series that Treasury.gov sources.

**Q: Why is `price` null?**
A: Constant‑maturity series are yields, not cash bonds. We don't synthesize clean prices from yield because converting requires a coupon / settlement convention that varies. Use the yield with a duration approximation if you need a price proxy.

**Q: How do I get a CSV?**
A: Apify dataset API: `GET /v2/datasets/{datasetId}/items?format=csv`. Or hit the Console export button.

**Q: Will this stay free in week 1?**
A: Yes — the pricing record sets `startedAt` to 14 days after publication, so all users get a free trial window.

**Q: Can I get a longer history?**
A: Set `date_range=ytd` for the current year. For multi‑year history, file a request — we keep the FRED back catalog up to the limit (DGS10 goes back to 1962).

***

### Roadmap

- TIPS (real yields, breakevens) — `DFII5`, `DFII10`, `DFII20`, `DFII30`.
- OIS / SOFR overlay for repo / funding context.
- On‑the‑run vs constant‑maturity reconciliation.
- Foreign sovereign curves (DE, UK, JP) under a separate sister actor.

***

### Support

- Apify Console: [console.apify.com](https://console.apify.com/)
- Issues / data requests: contact NexGenData via Apify messaging.
- Affiliate signup (1‑click): **<https://apify.com/nexgendata?fpr=2ayu9b>** — sign up under this link to support continued development of the fleet.

# Actor input Schema

## `tenors` (type: `array`):

List of Treasury tenors to fetch. Supported values: 1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y, 20Y, 30Y. Leave empty for the full curve.

## `date_range` (type: `string`):

Range of historical observations to include. 'today' returns just the latest print, 'last\_30d' / 'last\_90d' / 'ytd' return full history per tenor.

## `include_historical` (type: `boolean`):

If true, emit one record per (tenor, date) for the selected date\_range. If false, emit only the most recent record per tenor with rolling 1d/1w/1m/YTD change context.

## Actor input object example

```json
{
  "tenors": [
    "2Y",
    "5Y",
    "10Y",
    "30Y"
  ],
  "date_range": "today",
  "include_historical": false
}
```

# 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 = {
    "tenors": [
        "2Y",
        "5Y",
        "10Y",
        "30Y"
    ],
    "date_range": "today",
    "include_historical": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/treasury-yields-bonds").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 = {
    "tenors": [
        "2Y",
        "5Y",
        "10Y",
        "30Y",
    ],
    "date_range": "today",
    "include_historical": False,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/treasury-yields-bonds").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 '{
  "tenors": [
    "2Y",
    "5Y",
    "10Y",
    "30Y"
  ],
  "date_range": "today",
  "include_historical": false
}' |
apify call nexgendata/treasury-yields-bonds --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "💵 US Treasury Yields & Bond Data — Curve, 2s10s, Spreads",
        "description": "Track US Treasury yield curve from 1M to 30Y — daily yields, spreads, 2s10s curve inversion, historical changes. FRED + Treasury.gov public data for fixed income desks, asset allocators, macro hedge funds, treasury teams. Bloomberg yield curve alternative, no terminal needed. Pay-per-result.",
        "version": "0.0",
        "x-build-id": "nehpJSJbb664rbZVL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~treasury-yields-bonds/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-treasury-yields-bonds",
                "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/nexgendata~treasury-yields-bonds/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-treasury-yields-bonds",
                "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/nexgendata~treasury-yields-bonds/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-treasury-yields-bonds",
                "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": {
                    "tenors": {
                        "title": "Tenors",
                        "type": "array",
                        "description": "List of Treasury tenors to fetch. Supported values: 1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y, 20Y, 30Y. Leave empty for the full curve.",
                        "default": [
                            "1M",
                            "3M",
                            "6M",
                            "1Y",
                            "2Y",
                            "3Y",
                            "5Y",
                            "7Y",
                            "10Y",
                            "20Y",
                            "30Y"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "date_range": {
                        "title": "Date Range",
                        "enum": [
                            "today",
                            "last_30d",
                            "last_90d",
                            "ytd"
                        ],
                        "type": "string",
                        "description": "Range of historical observations to include. 'today' returns just the latest print, 'last_30d' / 'last_90d' / 'ytd' return full history per tenor.",
                        "default": "today"
                    },
                    "include_historical": {
                        "title": "Include Historical Series",
                        "type": "boolean",
                        "description": "If true, emit one record per (tenor, date) for the selected date_range. If false, emit only the most recent record per tenor with rolling 1d/1w/1m/YTD change context.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
