# USAspending.gov New Award Monitor (`bytehavenstudios/usaspending-award-monitor`) Actor

Monitor new federal contract and grant awards from USAspending.gov (US Treasury / DATA Act). Filter by agency, award type (contracts, grants, loans, direct payments), NAICS, PSC, recipient and amount; one normalized record per prime award as it lands, with a new-since-last-run mode. Keyless, CC0.

- **URL**: https://apify.com/bytehavenstudios/usaspending-award-monitor.md
- **Developed by:** [ByteHaven Studios](https://apify.com/bytehavenstudios) (community)
- **Categories:** Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 award returneds

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

## USAspending.gov New Award Monitor

Monitor **new federal contract and grant awards** from **USAspending.gov** (U.S. Treasury / DATA
Act) in a single run. Give it award types, an awarding agency, and/or NAICS / PSC / recipient /
amount filters; it returns one normalized record per prime award as it lands, with a
**new-since-last-run** mode over the nightly-refreshed FPDS (contracts) + FABS (grants) feeds.

Clean REST/JSON — no browser, no proxy, no login, no API key required. The award-search endpoint is
a **POST** API with JSON bodies. **Data source: USAspending.gov (U.S. federal, public domain,
CC0 1.0).**

> **Status: scaffold (v0.1, in progress).** This Actor is being built in slices; the runtime logic
> (`src/usaspending.js`, `src/filters.js`, `src/main.js`) is landing incrementally. This README
> documents the intended product surface. See `CHANGELOG.md` for what's implemented so far.

---

### What it does

For each run it queries the USAspending **`POST /api/v2/search/spending_by_award/`** endpoint for the
award types you select, over a time window (by `new_awards_only`, `action_date`, `last_modified_date`,
or `date_signed`), applies your filters, pages until `page_metadata.hasNext=false`, dedupes on
`Award ID` / `generated_internal_id`, and pushes one dataset item per award.

- **New awards** (default): with `dateType = new_awards_only`, only awards first created in the
  window — every agency, in one pass.
- **POST-barrier moat**: federal spending is enormous, deeply nested, and gated behind POST bodies
  with award-type-specific schemas, which structurally deters GET-scraping farms. Freshness
  (nightly reload) + breadth (every agency) + the POST barrier is the edge.
- **New-award monitor**: `monitorNewOnly` persists the set of already-reported award IDs (in the
  Actor's key-value store) and, on the next scheduled run, returns only awards not seen before.
- **Filters**: by `awardTypeCodes` (contracts A/B/C/D, grants 02–05, direct payments, loans),
  `agencies`, `naicsCodes`, `pscCodes`, `recipients`, and `minAmount`.

### Inputs

| Input | Type | Notes |
|---|---|---|
| `awardTypeCodes` | string[] | `A/B/C/D` contracts, `02–05` grants, `06/10` direct payments, `07/08` loans. Empty = A,B,C,D |
| `dateType` | string | `new_awards_only` (default), `action_date`, `last_modified_date`, `date_signed` |
| `since` | string | `YYYY-MM-DD` window start. Empty = recent trailing window |
| `until` | string | `YYYY-MM-DD` window end. Empty = today |
| `agencies` | string[] | Awarding agency names. Empty = all |
| `naicsCodes` | string[] | NAICS industry codes (contracts). Empty = all |
| `pscCodes` | string[] | Product/Service Codes (contracts). Empty = all |
| `recipients` | string[] | Recipient (awardee) names. Empty = all |
| `minAmount` | integer | Minimum Award Amount (0 = no minimum) |
| `monitorNewOnly` | boolean | Return only award IDs not seen in a previous run |
| `fields` | string[] | Override the requested/kept output fields (empty = sensible default set) |
| `maxResults` | integer | Cap total awards returned (0 = no cap) |
| `proxyConfiguration` | object | Optional; the API is open and needs no proxy. Default: none |

### Output — one record per award

```json
{
  "award_id": "CONT_AWD_W912DR26C0001_9700_-NONE-_-NONE-",
  "generated_internal_id": "CONT_AWD_W912DR26C0001_9700_-NONE-_-NONE-",
  "recipient_name": "Example Engineering LLC",
  "award_amount": 4250000.0,
  "award_type": "D",
  "awarding_agency": "Department of Defense",
  "awarding_sub_agency": "Department of the Army",
  "start_date": "2026-07-08",
  "end_date": "2029-07-07",
  "last_modified_date": "2026-07-09",
  "isNew": true,
  "fetchedAt": "2026-07-10T14:00:00.000Z"
}
````

`award_id` is USAspending's display `Award ID`; `generated_internal_id` is the stable dedupe/detail
key (feeds `GET /awards/{award_id}/`). Amounts are numeric USD; date fields are `YYYY-MM-DD` (null
when absent). `isNew` is `true` when an award ID was not seen in a previous run (only meaningful with
`monitorNewOnly`). The exact kept-field set depends on `fields` and the award families in the run
(contracts vs grants expose different selectable fields).

#### Control records (not charged)

Two non-award records may be pushed to signal run state. Neither triggers an `award-returned` charge:

| Record | When | Shape |
|---|---|---|
| `_noData` | The API returned no awards for the requested filters/window | `{ "_noData": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |
| `_error` | The fetch failed after retries, or normalization threw | `{ "_error": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |

`_noData` keeps a zero-result run green and auditable rather than pushing a silent empty dataset.

### Pricing (pay-per-event)

One **`award-returned`** event is charged per award record pushed to the dataset. Cost scales with
results, not runtime. Use `awardTypeCodes` / `agencies` / `minAmount` / `maxResults` / `monitorNewOnly`
to keep spend proportional to signal. (Live price shown on the Store page; see `docs/PRICING.md`.)

### Data source & attribution

USAspending.gov's code and data are released under a **Creative Commons CC0 1.0 Universal**
dedication and the underlying federal spending data is public domain (17 U.S.C. §105) — free to copy,
modify and redistribute, including commercially, without asking permission. No key and no attribution
are required; we credit the U.S. Treasury / USAspending.gov as a courtesy. Full compliance record:
`COMPLIANCE.md` (lands in a later slice).

> USAspending relays agency-reported data; awards may be corrected, re-reported, or lag the agencies'
> own systems, and prime-vs-sub-award distinctions apply. This Actor relays the data as published; it
> does not certify accuracy.

### Maintenance notes

- **Award-type-dependent schema** — `award_type_codes` and the selectable `fields` list differ per
  award family and shift across API versions; the normalizer keeps the common fields and is defensive.
- **Nightly reload windows** — FPDS/FABS reload nightly, so a monitoring schedule should overlap its
  time window run-to-run; `last_modified_date` mode catches re-reported awards.
- **Pagination** — `limit` is capped (100) and `page` is bounded; page until `hasNext=false`, dedupe
  on award ID.
- **Prime vs sub-award** — this Actor monitors **prime** awards; sub-awards are a separate endpoint.
- **Fiscal-year bulk reloads** churn `last_modified_date`, which can inflate `last_modified_date`-mode
  windows near FY boundaries.

# Actor input Schema

## `awardTypeCodes` (type: `array`):

USAspending award\_type\_codes to monitor. A/B/C/D = contracts; 02/03/04/05 = grants; 06/10 = direct payments; 07/08 = loans; IDV\_A…IDV\_E = indefinite-delivery vehicles. Empty = the four prime contract types (A, B, C, D). Note: the API's selectable `fields` list is award-type-dependent — mixing contracts and grants keeps only the common fields.

## `dateType` (type: `string`):

Which award date the time window filters on. new\_awards\_only = only awards first created in the window (the new-award moat); action\_date = any transaction action in the window; last\_modified\_date = re-poll changed awards (catches nightly reloads); date\_signed = contract signing date.

## `since` (type: `string`):

Start of the time window (maps to time\_period\[].start\_date). Leave empty to default to a recent trailing window. Ignored if 'Only new since last run' is on (the stored watermark drives the window instead).

## `until` (type: `string`):

End of the time window (maps to time\_period\[].end\_date). Leave empty to default to today.

## `agencies` (type: `array`):

Restrict to these awarding agency names (USAspending `Awarding Agency`), e.g. "Department of Defense". Empty = all agencies.

## `naicsCodes` (type: `array`):

Restrict to these NAICS industry codes (contracts). Empty = all.

## `pscCodes` (type: `array`):

Restrict to these Product/Service Codes (contracts). Empty = all.

## `recipients` (type: `array`):

Restrict to these recipient (awardee) names (USAspending `Recipient Name`). Empty = all recipients.

## `minAmount` (type: `integer`):

Only return awards whose Award Amount is at least this value. 0 = no minimum.

## `monitorNewOnly` (type: `boolean`):

Persist the set of award IDs already reported (in the Actor's key-value store) and, on the next run, return only awards not seen before. Turns this Actor into a new-award monitor across scheduled runs.

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

Optional. Override the set of USAspending fields requested and kept on each output record. Empty = a sensible default set (see README). Example extras: "NAICS", "PSC", "Description", "Recipient DUNS Number", "Place of Performance State Code".

## `maxResults` (type: `integer`):

Cap the total number of awards returned (across all selected award types). 0 = no cap (paginate until hasNext=false). Prefilled to 100 (one page) so a first/demo run finishes fast — federal prime awards run to tens of thousands per week, so leave 0 only when you deliberately want the full unbounded pull on a schedule.

## `proxyConfiguration` (type: `object`):

Optional. The USAspending API is a clean, open, public endpoint and needs NO proxy. You may enable Apify Proxy only to distribute requests if you run very large historical pulls. Default: no proxy.

## Actor input object example

```json
{
  "awardTypeCodes": [
    "A",
    "B",
    "C",
    "D"
  ],
  "dateType": "new_awards_only",
  "since": "2026-07-01",
  "until": "2026-07-10",
  "agencies": [],
  "naicsCodes": [],
  "pscCodes": [],
  "recipients": [],
  "minAmount": 0,
  "monitorNewOnly": false,
  "fields": [],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `awards` (type: `string`):

One U.S. federal prime award from USAspending.gov per item. Rendered as the Awards table (see the dataset schema).

# 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 = {
    "awardTypeCodes": [
        "A",
        "B",
        "C",
        "D"
    ],
    "agencies": [],
    "naicsCodes": [],
    "pscCodes": [],
    "recipients": [],
    "fields": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("bytehavenstudios/usaspending-award-monitor").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 = {
    "awardTypeCodes": [
        "A",
        "B",
        "C",
        "D",
    ],
    "agencies": [],
    "naicsCodes": [],
    "pscCodes": [],
    "recipients": [],
    "fields": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("bytehavenstudios/usaspending-award-monitor").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 '{
  "awardTypeCodes": [
    "A",
    "B",
    "C",
    "D"
  ],
  "agencies": [],
  "naicsCodes": [],
  "pscCodes": [],
  "recipients": [],
  "fields": [],
  "maxResults": 100
}' |
apify call bytehavenstudios/usaspending-award-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USAspending.gov New Award Monitor",
        "description": "Monitor new federal contract and grant awards from USAspending.gov (US Treasury / DATA Act). Filter by agency, award type (contracts, grants, loans, direct payments), NAICS, PSC, recipient and amount; one normalized record per prime award as it lands, with a new-since-last-run mode. Keyless, CC0.",
        "version": "0.1",
        "x-build-id": "0gDGV3gZTJSaXOtgf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bytehavenstudios~usaspending-award-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bytehavenstudios-usaspending-award-monitor",
                "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/bytehavenstudios~usaspending-award-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bytehavenstudios-usaspending-award-monitor",
                "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/bytehavenstudios~usaspending-award-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bytehavenstudios-usaspending-award-monitor",
                "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": {
                    "awardTypeCodes": {
                        "title": "Award type codes",
                        "type": "array",
                        "description": "USAspending award_type_codes to monitor. A/B/C/D = contracts; 02/03/04/05 = grants; 06/10 = direct payments; 07/08 = loans; IDV_A…IDV_E = indefinite-delivery vehicles. Empty = the four prime contract types (A, B, C, D). Note: the API's selectable `fields` list is award-type-dependent — mixing contracts and grants keeps only the common fields.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "02",
                                "03",
                                "04",
                                "05",
                                "06",
                                "10",
                                "07",
                                "08"
                            ],
                            "enumTitles": [
                                "A — BPA call (contract)",
                                "B — Purchase order (contract)",
                                "C — Delivery order (contract)",
                                "D — Definitive contract",
                                "02 — Block grant",
                                "03 — Formula grant",
                                "04 — Project grant",
                                "05 — Cooperative agreement",
                                "06 — Direct payment for specified use",
                                "10 — Direct payment with unrestricted use",
                                "07 — Direct loan",
                                "08 — Guaranteed/insured loan"
                            ]
                        }
                    },
                    "dateType": {
                        "title": "Date type for the time window",
                        "enum": [
                            "new_awards_only",
                            "action_date",
                            "last_modified_date",
                            "date_signed"
                        ],
                        "type": "string",
                        "description": "Which award date the time window filters on. new_awards_only = only awards first created in the window (the new-award moat); action_date = any transaction action in the window; last_modified_date = re-poll changed awards (catches nightly reloads); date_signed = contract signing date.",
                        "default": "new_awards_only"
                    },
                    "since": {
                        "title": "Window start (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Start of the time window (maps to time_period[].start_date). Leave empty to default to a recent trailing window. Ignored if 'Only new since last run' is on (the stored watermark drives the window instead)."
                    },
                    "until": {
                        "title": "Window end (YYYY-MM-DD)",
                        "type": "string",
                        "description": "End of the time window (maps to time_period[].end_date). Leave empty to default to today."
                    },
                    "agencies": {
                        "title": "Awarding agencies",
                        "type": "array",
                        "description": "Restrict to these awarding agency names (USAspending `Awarding Agency`), e.g. \"Department of Defense\". Empty = all agencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "naicsCodes": {
                        "title": "NAICS codes",
                        "type": "array",
                        "description": "Restrict to these NAICS industry codes (contracts). Empty = all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pscCodes": {
                        "title": "PSC codes",
                        "type": "array",
                        "description": "Restrict to these Product/Service Codes (contracts). Empty = all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recipients": {
                        "title": "Recipient names",
                        "type": "array",
                        "description": "Restrict to these recipient (awardee) names (USAspending `Recipient Name`). Empty = all recipients.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minAmount": {
                        "title": "Minimum award amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return awards whose Award Amount is at least this value. 0 = no minimum.",
                        "default": 0
                    },
                    "monitorNewOnly": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Persist the set of award IDs already reported (in the Actor's key-value store) and, on the next run, return only awards not seen before. Turns this Actor into a new-award monitor across scheduled runs.",
                        "default": false
                    },
                    "fields": {
                        "title": "Fields to keep",
                        "type": "array",
                        "description": "Optional. Override the set of USAspending fields requested and kept on each output record. Empty = a sensible default set (see README). Example extras: \"NAICS\", \"PSC\", \"Description\", \"Recipient DUNS Number\", \"Place of Performance State Code\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max awards per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the total number of awards returned (across all selected award types). 0 = no cap (paginate until hasNext=false). Prefilled to 100 (one page) so a first/demo run finishes fast — federal prime awards run to tens of thousands per week, so leave 0 only when you deliberately want the full unbounded pull on a schedule.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The USAspending API is a clean, open, public endpoint and needs NO proxy. You may enable Apify Proxy only to distribute requests if you run very large historical pulls. Default: no proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```