# US Treasury Fiscal Data Scraper (`automation-lab/us-treasury-fiscal-data-scraper`) Actor

Export official US Treasury FiscalData records for debt, rates, exchange rates, statements, and interest expense into clean datasets.

- **URL**: https://apify.com/automation-lab/us-treasury-fiscal-data-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## US Treasury Fiscal Data Scraper

Export official US Treasury FiscalData API records for debt, interest rates, exchange rates, monthly statements, interest expense, and savings bond sales.

### What does US Treasury Fiscal Data Scraper do?

US Treasury Fiscal Data Scraper pulls structured JSON records from the official Treasury FiscalData API and saves them as clean Apify dataset items.

It is built for repeatable fiscal-data workflows where teams need current public finance records in dashboards, alerts, spreadsheets, data warehouses, or automated reporting jobs.

The actor uses the official keyless API at `api.fiscaldata.treasury.gov`. No login, cookies, browser automation, or proxy is required.

### Who is it for?

- 📊 Financial analysts tracking US debt, rates, and fiscal balances.
- 🏦 Public-finance teams building recurring Treasury dashboards.
- 📰 Journalists monitoring public debt and federal fiscal trends.
- 🧪 Market researchers comparing macroeconomic indicators.
- 🏛️ Government-data vendors normalizing public datasets for customers.
- ⚙️ Data engineers who need scheduled FiscalData API exports without maintaining custom scripts.

### Why use this Treasury FiscalData extractor?

- ✅ Official Treasury source.
- ✅ Keyless HTTP API; no scraping browser overhead.
- ✅ Multiple high-value datasets in one run.
- ✅ Date range filters for incremental exports.
- ✅ Raw official row preservation for audit trails.
- ✅ Normalized amount, value, category, date, country, and currency fields.
- ✅ Apify scheduling, webhooks, datasets, API access, and integrations.

### Supported Treasury datasets

| Dataset | Input value | Example fields |
| --- | --- | --- |
| Debt to the Penny | `debt_to_penny` | total public debt, public debt held, intragovernmental holdings |
| Average Interest Rates | `avg_interest_rates` | security type, security description, average rate |
| Rates of Exchange | `rates_of_exchange` | country, currency, exchange rate |
| Monthly Treasury Statement Table 1 | `monthly_treasury_statement` | receipts, outlays, deficit/surplus |
| Interest Expense | `interest_expense` | monthly and fiscal YTD public debt interest expense |
| Savings Bonds Securities Sales | `securities_sales` | gross sales, returned sales, net sales, count |

### What data can you extract?

Each output item contains a common normalized record shape:

| Field | Description |
| --- | --- |
| `datasetId` | Stable dataset identifier selected in input |
| `datasetName` | Human-readable Treasury dataset name |
| `endpoint` | FiscalData API endpoint path |
| `recordDate` | Official record date |
| `fiscalYear` | Fiscal year, when provided |
| `fiscalQuarter` | Fiscal quarter, when provided |
| `calendarYear` | Calendar year, when provided |
| `calendarMonth` | Calendar month, when provided |
| `category` | Dataset-specific category such as security type or classification |
| `subcategory` | Dataset-specific subcategory |
| `country` | Exchange-rate country, when applicable |
| `currency` | Exchange-rate currency, when applicable |
| `amount` | Primary numeric amount for the record |
| `amountType` | Label describing the amount |
| `value` | Primary numeric/string value such as rate or count |
| `valueType` | Label describing the value |
| `sourceLineNumber` | Treasury source line number, when available |
| `rawData` | Complete official FiscalData row |
| `sourceUrl` | Exact API URL used for the page |
| `fetchedAt` | Actor fetch timestamp |

### How much does it cost to scrape US Treasury fiscal data?

The actor uses pay-per-event pricing.

- Start event: $0.005 per run.
- Each saved Treasury record is charged as one `item` event.
- Larger usage tiers receive discounted per-record pricing.

| Tier | Price per Treasury record |
| --- | ---: |
| Free | $0.000030363 |
| Starter / Bronze | $0.000026402 |
| Silver | $0.000020594 |
| Gold | $0.000015841 |
| Platinum | $0.000010561 |
| Diamond | $0.000010000 |

Because the actor uses the official HTTP API and no paid proxy, it is designed for low operating cost and high margin at dashboard scale.

### Quick start

1. Open the actor on Apify.
2. Choose one or more Treasury datasets.
3. Set `maxRecords` to the number of rows you need.
4. Optionally set `startDate` and `endDate`.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, RSS, or through the Apify API.

### Input settings

#### `datasets`

Choose one or more official FiscalData datasets. Records are fetched in the order selected.

#### `startDate`

Optional lower bound for `record_date` in `YYYY-MM-DD` format.

#### `endDate`

Optional upper bound for `record_date` in `YYYY-MM-DD` format.

#### `filters`

Advanced FiscalData filter expression, such as `country:eq:Canada` or `security_type_desc:eq:Marketable`.

#### `sort`

Choose newest-first or oldest-first by `record_date`.

#### `maxRecords`

Maximum dataset records to save across all selected datasets.

#### `pageSize`

FiscalData API page size. The default is 100 and the maximum is 1000.

#### `fields`

Optional official FiscalData field list. Leave empty to preserve complete rows.

#### `includeRawData`

Set to `true` to include the full official row in `rawData`. This is recommended for analysts.

### Example input

```json
{
  "datasets": ["debt_to_penny", "avg_interest_rates"],
  "startDate": "2025-01-01",
  "maxRecords": 250,
  "pageSize": 250,
  "sort": "newest",
  "includeRawData": true
}
````

### Example output

```json
{
  "datasetId": "debt_to_penny",
  "datasetName": "Debt to the Penny",
  "endpoint": "v2/accounting/od/debt_to_penny",
  "recordDate": "2026-07-02",
  "fiscalYear": 2026,
  "calendarYear": 2026,
  "amount": 39375254020492.22,
  "amountType": "Total public debt outstanding",
  "rawData": {
    "record_date": "2026-07-02",
    "tot_pub_debt_out_amt": "39375254020492.22"
  },
  "sourceUrl": "https://api.fiscaldata.treasury.gov/services/api/fiscal_service/...",
  "fetchedAt": "2026-07-04T00:00:00.000Z"
}
```

### Treasury debt monitoring workflow

Use `debt_to_penny` with a scheduled daily run to monitor public debt changes.

Send new rows to a webhook, spreadsheet, or BI table, then compare `amount` over time.

### Interest-rate research workflow

Use `avg_interest_rates` for recurring interest-rate exports.

Filter or group by `category` and `subcategory` to track marketable and non-marketable security trends.

### Exchange-rate workflow

Use `rates_of_exchange` to collect official Treasury reporting rates.

Add a FiscalData filter like `country:eq:Canada` when you need one country or leave filters blank for broad exports.

### Monthly Treasury Statement workflow

Use `monthly_treasury_statement` to collect receipts, outlays, and deficit/surplus rows.

This is useful for fiscal dashboards and macroeconomic reporting.

### Tips for reliable runs

- Keep `maxRecords` low while testing a new dashboard.
- Use `startDate` for incremental exports.
- Leave `includeRawData` enabled when you need auditability.
- Use `pageSize` 500 or 1000 for larger exports.
- Use official FiscalData filter syntax for advanced narrowing.

### Integrations

The actor works with common Apify integrations:

- 📥 Export to CSV or Excel for analyst review.
- 🧱 Send results to Google Sheets or Airtable with Apify integrations.
- 🗄️ Pull dataset items into Snowflake, BigQuery, or Postgres via API.
- 🔔 Trigger webhooks when new Treasury data is available.
- 🤖 Use from agents and automation tools through the Apify API.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/us-treasury-fiscal-data-scraper').call({
  datasets: ['debt_to_penny'],
  maxRecords: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/us-treasury-fiscal-data-scraper').call(run_input={
    'datasets': ['rates_of_exchange'],
    'maxRecords': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~us-treasury-fiscal-data-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"datasets":["interest_expense"],"maxRecords":100}'
```

### MCP usage

Use this actor from MCP-compatible tools with Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/us-treasury-fiscal-data-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-treasury-fiscal-data https://mcp.apify.com/?tools=automation-lab/us-treasury-fiscal-data-scraper
```

MCP JSON config block:

```json
{
  "mcpServers": {
    "apify-treasury-fiscal-data": {
      "url": "https://mcp.apify.com/?tools=automation-lab/us-treasury-fiscal-data-scraper"
    }
  }
}
```

Example prompts:

- "Run the US Treasury Fiscal Data Scraper for debt to the penny and summarize the latest total debt."
- "Export Treasury exchange rates for Canada and save the records as CSV."
- "Schedule a weekly Treasury interest expense monitor and notify me when new records appear."

### Claude Desktop setup

Add the Apify MCP server to Claude Desktop using the JSON config above, then enable the tool for this actor using:

```text
https://mcp.apify.com/?tools=automation-lab/us-treasury-fiscal-data-scraper
```

After setup, ask Claude to run the actor with your selected dataset and date range.

### Data source

The data source is the official US Treasury FiscalData API:

```text
https://api.fiscaldata.treasury.gov/services/api/fiscal_service/
```

The actor does not modify official values. It normalizes common fields and preserves `rawData` for verification.

### Legality and responsible use

This actor uses a public government API intended for data access.

Always verify whether your downstream use must cite the US Treasury or FiscalData source. For regulated financial workflows, validate extracted data before making decisions.

### Troubleshooting

#### Why did I get fewer records than expected?

Your date range or advanced filter may be too narrow. Remove `filters` or increase `maxRecords`.

#### Why are some normalized fields empty?

Treasury datasets have different schemas. Dataset-specific values are still available in `rawData` when `includeRawData` is enabled.

#### How do I fetch one country in exchange rates?

Use dataset `rates_of_exchange` and set `filters` to a FiscalData expression such as `country:eq:Canada`.

### Related scrapers

Other Automation Lab actors that pair well with this workflow:

- https://apify.com/automation-lab/sec-edgar-scraper
- https://apify.com/automation-lab/cfpb-complaints-scraper
- https://apify.com/automation-lab/imf-datamapper-scraper

### FAQ

#### Does this actor require an API key?

No. The Treasury FiscalData API is public and keyless for this workflow.

#### Does it use proxies?

No. It uses direct HTTPS requests to the official API.

#### Can I run it on a schedule?

Yes. Use Apify schedules to run daily, weekly, or monthly and export only records in your desired date range.

#### Can I choose custom FiscalData fields?

Yes. Add field names to `fields`. The actor automatically includes normalized date and period fields needed for output consistency.

#### Can I combine datasets?

Yes. Select multiple datasets and set `maxRecords` high enough for the combined export.

### Changelog

- 0.1 — Initial release with six curated Treasury FiscalData datasets.

# Actor input Schema

## `datasets` (type: `array`):

Choose one or more official FiscalData datasets to export. Records are emitted in the selected order until Max records is reached.

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

Optional record\_date lower bound in YYYY-MM-DD format.

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

Optional record\_date upper bound in YYYY-MM-DD format.

## `filters` (type: `string`):

Advanced: append a FiscalData filter expression, for example country:eq:Canada or security\_type\_desc:eq:Marketable.

## `sort` (type: `string`):

Sort records by record\_date.

## `maxRecords` (type: `integer`):

Maximum dataset rows to save across all selected Treasury datasets.

## `pageSize` (type: `integer`):

FiscalData API page size. Higher values reduce requests; max 1000.

## `fields` (type: `array`):

Optional FiscalData field list. Leave empty for the full official row. Required normalized fields are added automatically.

## `includeRawData` (type: `boolean`):

Include the complete FiscalData row in rawData for auditability and downstream custom transforms.

## Actor input object example

```json
{
  "datasets": [
    "debt_to_penny"
  ],
  "startDate": "2025-01-01",
  "sort": "newest",
  "maxRecords": 20,
  "pageSize": 100,
  "includeRawData": true
}
```

# Actor output Schema

## `overview` (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 = {
    "datasets": [
        "debt_to_penny"
    ],
    "startDate": "2025-01-01",
    "sort": "newest",
    "maxRecords": 20,
    "pageSize": 100,
    "includeRawData": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/us-treasury-fiscal-data-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 = {
    "datasets": ["debt_to_penny"],
    "startDate": "2025-01-01",
    "sort": "newest",
    "maxRecords": 20,
    "pageSize": 100,
    "includeRawData": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/us-treasury-fiscal-data-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 '{
  "datasets": [
    "debt_to_penny"
  ],
  "startDate": "2025-01-01",
  "sort": "newest",
  "maxRecords": 20,
  "pageSize": 100,
  "includeRawData": true
}' |
apify call automation-lab/us-treasury-fiscal-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/us-treasury-fiscal-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Treasury Fiscal Data Scraper",
        "description": "Export official US Treasury FiscalData records for debt, rates, exchange rates, statements, and interest expense into clean datasets.",
        "version": "0.1",
        "x-build-id": "e9gClGzjwGliLHY6F"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~us-treasury-fiscal-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-us-treasury-fiscal-data-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/automation-lab~us-treasury-fiscal-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-us-treasury-fiscal-data-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/automation-lab~us-treasury-fiscal-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-us-treasury-fiscal-data-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",
                "required": [
                    "datasets",
                    "maxRecords"
                ],
                "properties": {
                    "datasets": {
                        "title": "Datasets",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more official FiscalData datasets to export. Records are emitted in the selected order until Max records is reached.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "debt_to_penny",
                                "avg_interest_rates",
                                "rates_of_exchange",
                                "monthly_treasury_statement",
                                "interest_expense",
                                "securities_sales"
                            ],
                            "enumTitles": [
                                "Debt to the Penny",
                                "Average Interest Rates",
                                "Rates of Exchange",
                                "Monthly Treasury Statement Table 1",
                                "Interest Expense on Public Debt",
                                "Savings Bonds Securities Sales"
                            ]
                        },
                        "default": [
                            "debt_to_penny"
                        ]
                    },
                    "startDate": {
                        "title": "Start date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional record_date lower bound in YYYY-MM-DD format."
                    },
                    "endDate": {
                        "title": "End date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional record_date upper bound in YYYY-MM-DD format."
                    },
                    "filters": {
                        "title": "Additional FiscalData filter",
                        "type": "string",
                        "description": "Advanced: append a FiscalData filter expression, for example country:eq:Canada or security_type_desc:eq:Marketable."
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Sort records by record_date.",
                        "default": "newest"
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset rows to save across all selected Treasury datasets.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "FiscalData API page size. Higher values reduce requests; max 1000.",
                        "default": 100
                    },
                    "fields": {
                        "title": "Fields",
                        "type": "array",
                        "description": "Optional FiscalData field list. Leave empty for the full official row. Required normalized fields are added automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeRawData": {
                        "title": "Include raw official row",
                        "type": "boolean",
                        "description": "Include the complete FiscalData row in rawData for auditability and downstream custom transforms.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```