# Infrastructure Security Advisory Normalizer (`hankel_labs/infrastructure-advisory-normalizer`) Actor

Normalize CERT-Bund and Microsoft MSRC security advisories into one consistent schema. Match findings to your infrastructure stack, enrich them with CISA KEV and EPSS data, and prioritize them using a transparent, deterministic risk score.

- **URL**: https://apify.com/hankel\_labs/infrastructure-advisory-normalizer.md
- **Developed by:** [Fabian Hankel](https://apify.com/hankel_labs) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 prioritized advisories

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Infrastructure Security Advisory Normalizer

Merges security advisories from **CERT-Bund (BSI, Germany)** and **Microsoft MSRC**
into one clean schema, filters them against **your** infrastructure stack, enriches
them with **CISA KEV** (and optionally **EPSS**), and returns a deterministically
prioritized, machine-readable triage list — for MSP technicians, sysadmins,
automations and AI agents.

**This is not another NVD/CVE dump.** Generic CVE actors hand you the whole
database. This actor answers the question that actually costs you time every
week: *"Which of this week's advisories affect MY stack — and what do I patch
first?"* It deduplicates per source, normalizes product names and severities
across German and English sources, never hides an advisory because of uncertain
version data, and shows the full calculation behind every priority score.

### Input

```json
{
  "stack": [
    { "vendor": "microsoft", "product": "Exchange Server 2019" },
    { "vendor": "fortinet", "product": "FortiOS", "versions": ["7.4.2"] }
  ],
  "sources": ["cert-bund", "msrc"],
  "days_back": 14,
  "min_severity": "medium",
  "only_known_exploited": false,
  "status": "both",
  "max_results": 100
}
````

- `stack` is **required** (at least one entry with `vendor`). `product` and
  `versions` are optional.
- **Simple mode:** omit `versions` — matching happens on product level and the
  result is clearly flagged as `product_match_version_unknown`.
- Vendor-only entries (`{"vendor": "fortinet"}`) return all advisories of that
  vendor with `vendor_match_only` confidence.

> **Quick start:** the input form is prefilled with a fast MSRC-only demo
> (Windows Server 2022, last 45 days, a few results in seconds). For a full
> triage keep both `sources` and set your own `stack` — the JSON above is the
> full-run default that API calls get when a field is omitted.

### Example configurations (copy-paste)

#### 1. Weekly Stack Triage (Microsoft on-prem)

Monday-morning triage for a typical Microsoft stack: every matching advisory from
the last 7 days, ranked P1–P4, ready for your ticket system. Copy it, change the
stack to yours, run it on a weekly schedule.

```json
{
  "stack": [
    { "vendor": "microsoft", "product": "Exchange Server 2019" },
    { "vendor": "microsoft", "product": "Windows Server 2022" },
    { "vendor": "microsoft", "product": "Hyper-V" }
  ],
  "sources": ["cert-bund", "msrc"],
  "days_back": 7,
  "min_severity": "medium",
  "status": "both",
  "max_results": 100
}
```

#### 2. Known-Exploited Watch (30 days)

Only what is actually being exploited: advisories listed in CISA KEV or flagged
`Exploited: Yes` by the vendor, across your vendors. Near-empty most weeks — loud
when it matters. Run it daily or weekly.

```json
{
  "stack": [
    { "vendor": "microsoft" },
    { "vendor": "fortinet" },
    { "vendor": "vmware" }
  ],
  "sources": ["cert-bund", "msrc"],
  "days_back": 30,
  "only_known_exploited": true,
  "min_severity": "low",
  "status": "both",
  "max_results": 50
}
```

Vendor-only entries match every advisory of that vendor (`vendor_match_only`);
the KEV/exploited filter is what keeps this config quiet.

### Use it from n8n

Ready-made workflow: [`examples/n8n_weekly_triage.json`](examples/n8n_weekly_triage.json)
(Schedule → Actor → filter P1/P2 → e-mail).

1. n8n → **Workflows → Import from File** → pick `n8n_weekly_triage.json`.
2. Set `APIFY_TOKEN` as an environment variable in n8n (or replace the query
   parameter with an n8n credential) — do not paste the token into the workflow.
3. Edit the `stack` in the **Apify: run advisory triage** node to your products.
4. Change the recipient in **Email the finding** (or swap the node for Slack).
5. Activate. It fires Mondays 07:00 and only e-mails P1/P2 findings.

It calls `run-sync-get-dataset-items`, so the workflow receives the finished
dataset items directly — one n8n item per matched advisory. If your n8n version
wraps the response in a single item, add a **Split Out** node after the HTTP
Request.

### Use it from AI agents (MCP)

The actor is plain request/response with a strict input schema, so it works well
as an agent tool — no browser, no session state, deterministic output.

- **Via Apify MCP:** expose your Apify actors to an MCP-capable client (Claude,
  Cursor, or any MCP host) and call this actor by name
  (`hankel_labs/infrastructure-advisory-normalizer`). The agent supplies the same
  JSON input documented above.
- **Directly over HTTP:** `POST https://api.apify.com/v2/acts/hankel_labs~infrastructure-advisory-normalizer/run-sync-get-dataset-items?token=…`
  with the input JSON returns the ranked advisories in one call.
- **Why it suits agents:** every item carries `match_reason`, `match_confidence`
  and a `priority_breakdown` that sums exactly to `priority_score` — an agent can
  explain *why* something is on the list instead of guessing.
- Pay-per-result billing works for agentic use too: you are charged per emitted
  advisory, and `max_results` caps the cost of any single agent call.

### Output (one dataset item per matched advisory)

Key fields (full example in `examples/output.example.json`):

| Field | Meaning |
|---|---|
| `advisory_id`, `source`, `source_url` | Stable source ID (WID-SEC-… / CVE-…) and original link |
| `normalized_product` / `original_product` | Curated alias slug vs. raw source name |
| `severity` + `severity_source` | Normalized low/medium/high/critical; `vendor`, `derived-cvss` or `default-unknown` |
| `cvss`, `cves`, `epss`, `known_exploited` | Vendor CVSS, CVE list, EPSS score, CISA-KEV / vendor "Exploited: Yes" |
| `affected_versions`, `fixed_versions` | As published by the source |
| `status` | `new` or `updated` within the window |
| `action_type` | `patch_available`, `workaround_only`, `mitigation`, `no_fix_yet`, `informational` |
| `matched_stack_item`, `match_reason`, `match_confidence` | Why this advisory concerns *your* stack |
| `priority_score`, `priority_band`, `priority_breakdown` | Deterministic score with the full calculation |

A `summary.json` (run window, per-source status, enrichment status, result
counts, truncation flag) is stored in the run's key-value store.

### Match confidence — and the safety rule

| Confidence | Meaning |
|---|---|
| `exact_version_match` | Your version is provably inside a published affected range |
| `product_match_version_unknown` | Product matches; versions missing or not comparable |
| `vendor_match_only` | Stack entry named only the vendor |

**The actor never claims "not affected" based on uncertain version data.** An
advisory is only excluded when every published version spec was machine-readable
and your versions are provably outside all of them. Anything uncertain is
included, explained in `match_reason`, and scored with lower confidence.

### Priority logic (v0.1, fully deterministic — no AI scoring)

| Component | Points |
|---|---|
| Severity critical / high / medium / low | 40 / 30 / 15 / 5 |
| CISA KEV or vendor "Exploited: Yes" | +30 |
| EPSS ≥ 0.5 / ≥ 0.1 | +20 / +10 |
| Exact version match / product-level match | +15 / +5 |
| Internet-exposed product class (firewall, VPN, mail, hypervisor mgmt, backup, …) | +10 |
| Patch available | +5 |
| New advisory | +5 |

Capped at 100. Bands: **P1 ≥ 80, P2 ≥ 60, P3 ≥ 40, P4 < 40.**
`priority_breakdown` in every item contains the exact calculation including the
cap adjustment — the score is reproducible from the result itself.

### Data sources & fetch behavior

- **CERT-Bund WID** — official CSAF 2.0 feed (TLP:CLEAR), published by BSI
  explicitly for automated retrieval: `wid.cert-bund.de/.well-known/csaf/`
  (changes.csv, falling back to year directory listings).
- **Microsoft MSRC** — public CVRF v3.0 API (no authentication required):
  `api.msrc.microsoft.com/cvrf/v3.0/`.
- **CISA KEV** — single public JSON catalog, cached per run.
- **EPSS** — FIRST.org API, optional; if unavailable the run continues and the
  score component is 0.

Polite by design: plain HTTPS GETs with an identifying User-Agent, self-imposed
rate limiting, per-run caching, a hard cap of 600 source documents per run.
**No browser automation, no proxies, no scraping of personal data, no LLM at
runtime.** One failing source never stops the run — the summary reports it.

### Limits & disclaimer

- Best-effort aggregation of public advisories. **No guarantee of completeness
  or correctness.** This actor does **not** provide a full vulnerability
  assessment and is **not** a compliance product — it does not by itself fulfil
  NIS2, ISO 27001 or any regulatory obligation. It supports your triage;
  verification against the linked original advisory remains your job.
- MSRC publishes affected products mostly without comparable version ranges;
  those matches are honestly reported as `product_match_version_unknown` with
  `fixed_versions` (builds/KBs) attached.
- CERT-Bund documents often reference vendor fixes without explicit fixed
  version strings; `action_type` still reflects them.
- Fortinet PSIRT is planned as v0.2 (after the core proves itself) and is not
  part of this version.

### Pricing

Pay-per-event: a synthetic `apify-actor-start` ($0.00005, triggered automatically
by Apify) plus `source-scan` ($0.02 per successfully scanned source) and
`prioritized-advisory` ($0.02 per emitted advisory, the primary event). A minimum
two-source run with no matches is therefore about **$0.04005**.

**Worked example (real test run):** a two-source run capped at 10 emitted
advisories charged **$0.24005** in events (1 start + 2 source-scans + 10 advisories).
Narrow stacks usually cost cents per run; **broad Microsoft stacks around Patch
Tuesday can reach $1–3 or more** — control cost via `max_results`, a short
`days_back` window, `min_severity` and your platform spending limit. `max_results`
caps your cost.

On top of the event price you also pay Apify's normal **platform usage** (compute,
data transfer); for the test run above that was about **$0.019** of compute. Under
"pay per event + usage" this variable usage is billed to the run as usual.

Charging is **fail-closed**: an advisory is only emitted after its charge
succeeded; when your spending limit is reached the actor stops cleanly and flags
`truncated` in `summary.json`; a real billing error aborts the run instead of
silently emitting paid results for free. Details in `docs/PRICING.md`.

**Memory:** the configured minimum of **1024 MB** is sufficient — no need to raise
it. Peak resident memory measured in the release live runs was **~76 MB** (MSRC
month run 72 MB; combined CERT-Bund + MSRC run 76 MB), far below the 700 MB
threshold that would have required 2048 MB. These are **local (Windows)
measurements**; the Apify container value is confirmed on the platform run — see
`docs/RUN_REPORT.md`.

### Local development

```bash
python3 -m unittest discover -s tests -v   # offline test suite (no network)
apify run --purge --input-file=examples/input.example.json
apify push
```

***

### Kurzfassung auf Deutsch

Dieser Actor führt Sicherheitswarnungen von **CERT-Bund (BSI)** und **Microsoft
MSRC** in ein einheitliches Schema zusammen, filtert sie gegen **Ihren** Stack,
reichert sie mit **CISA KEV** (und EPSS) an und priorisiert deterministisch mit
offengelegtem Rechenweg. Unsichere Versionsangaben führen **nie** zum
Ausschluss eines Advisories — sie werden aufgenommen, begründet und mit
niedrigerer Konfidenz gekennzeichnet. Kein NVD-Dump: beantwortet wird die
Frage „Was davon betrifft meinen Stack diese Woche, und was zuerst?".
Keine Compliance-Garantie und kein Ersatz für eine vollständige
Schwachstellenbewertung; bitte immer die verlinkte Originalquelle prüfen.

# Actor input Schema

## `stack` (type: `array`):

At least one entry. Each entry: vendor (required, non-empty), product (optional), versions (optional list of strings). Omit versions for simple mode - matching then happens on product level and is clearly flagged.

## `sources` (type: `array`):

Advisory sources to scan.

## `days_back` (type: `integer`):

Look-back window in days (1-90).

## `min_severity` (type: `string`):

Advisories below this normalized severity are dropped.

## `only_known_exploited` (type: `boolean`):

Keep only advisories in CISA KEV or flagged 'Exploited: Yes' by the vendor.

## `status` (type: `string`):

Return new advisories, updated ones, or both.

## `max_results` (type: `integer`):

Hard cap on emitted (and charged) advisories.

## Actor input object example

```json
{
  "stack": [
    {
      "vendor": "microsoft",
      "product": "Windows Server 2022"
    }
  ],
  "sources": [
    "msrc"
  ],
  "days_back": 45,
  "min_severity": "medium",
  "only_known_exploited": false,
  "status": "both",
  "max_results": 3
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset: one item per matched, prioritized advisory.

## `summary` (type: `string`):

summary.json record in the default key-value store.

# 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 = {
    "stack": [
        {
            "vendor": "microsoft",
            "product": "Windows Server 2022"
        }
    ],
    "sources": [
        "msrc"
    ],
    "days_back": 45,
    "min_severity": "medium",
    "max_results": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("hankel_labs/infrastructure-advisory-normalizer").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 = {
    "stack": [{
            "vendor": "microsoft",
            "product": "Windows Server 2022",
        }],
    "sources": ["msrc"],
    "days_back": 45,
    "min_severity": "medium",
    "max_results": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("hankel_labs/infrastructure-advisory-normalizer").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 '{
  "stack": [
    {
      "vendor": "microsoft",
      "product": "Windows Server 2022"
    }
  ],
  "sources": [
    "msrc"
  ],
  "days_back": 45,
  "min_severity": "medium",
  "max_results": 3
}' |
apify call hankel_labs/infrastructure-advisory-normalizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hankel_labs/infrastructure-advisory-normalizer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Infrastructure Security Advisory Normalizer",
        "description": "Normalize CERT-Bund and Microsoft MSRC security advisories into one consistent schema. Match findings to your infrastructure stack, enrich them with CISA KEV and EPSS data, and prioritize them using a transparent, deterministic risk score.",
        "version": "0.1",
        "x-build-id": "795Mf0Kqh29HJgMKC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hankel_labs~infrastructure-advisory-normalizer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hankel_labs-infrastructure-advisory-normalizer",
                "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/hankel_labs~infrastructure-advisory-normalizer/runs": {
            "post": {
                "operationId": "runs-sync-hankel_labs-infrastructure-advisory-normalizer",
                "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/hankel_labs~infrastructure-advisory-normalizer/run-sync": {
            "post": {
                "operationId": "run-sync-hankel_labs-infrastructure-advisory-normalizer",
                "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": [
                    "stack"
                ],
                "properties": {
                    "stack": {
                        "title": "Infrastructure stack (required)",
                        "minItems": 1,
                        "type": "array",
                        "description": "At least one entry. Each entry: vendor (required, non-empty), product (optional), versions (optional list of strings). Omit versions for simple mode - matching then happens on product level and is clearly flagged.",
                        "items": {
                            "type": "object",
                            "required": [
                                "vendor"
                            ],
                            "properties": {
                                "vendor": {
                                    "title": "Vendor",
                                    "type": "string",
                                    "minLength": 1,
                                    "description": "Vendor name, e.g. microsoft or fortinet (required, non-empty)."
                                },
                                "product": {
                                    "title": "Product",
                                    "type": "string",
                                    "description": "Optional product name, e.g. Exchange Server 2019. Omit for vendor-level matching."
                                },
                                "versions": {
                                    "title": "Versions",
                                    "type": "array",
                                    "items": {
                                        "type": "string"
                                    },
                                    "description": "Optional list of version strings. Omit for product-level matching."
                                }
                            }
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Advisory sources to scan.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cert-bund",
                                "msrc"
                            ]
                        },
                        "default": [
                            "cert-bund",
                            "msrc"
                        ]
                    },
                    "days_back": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Look-back window in days (1-90).",
                        "default": 14
                    },
                    "min_severity": {
                        "title": "Minimum severity",
                        "enum": [
                            "low",
                            "medium",
                            "high",
                            "critical"
                        ],
                        "type": "string",
                        "description": "Advisories below this normalized severity are dropped.",
                        "default": "medium"
                    },
                    "only_known_exploited": {
                        "title": "Only known exploited",
                        "type": "boolean",
                        "description": "Keep only advisories in CISA KEV or flagged 'Exploited: Yes' by the vendor.",
                        "default": false
                    },
                    "status": {
                        "title": "Advisory status",
                        "enum": [
                            "new",
                            "updated",
                            "both"
                        ],
                        "type": "string",
                        "description": "Return new advisories, updated ones, or both.",
                        "default": "both"
                    },
                    "max_results": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted (and charged) advisories.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```