# NL Netcongestie Monitor (Grid Congestion Checker) (`codeclouds/nl-netcongestie-monitor`) Actor

Checkt per postcode/adres of er netcongestie is op het Nederlandse elektriciteitsnet, via de officiele landelijke Capaciteitskaart van Netbeheer Nederland en TenneT.

- **URL**: https://apify.com/codeclouds/nl-netcongestie-monitor.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 locatie-resultaats

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/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

## NL Netcongestie Monitor (Grid Congestion Checker) 🇳🇱⚡

Check **electricity grid congestion status per postcode, address, or coordinate** in the Netherlands — consumption and feed-in capacity, queue size (MW), and expected resolution year — straight from the official national **Capaciteitskaart** published by Netbeheer Nederland (all regional grid operators) and TenneT (national high-voltage grid).

Dutch grid operators (Liander, Enexis, Stedin, Coteq, Westland Infra, Rendo, TenneT) publish a weekly-updated map showing where there is no room left on the electricity grid for a new or larger connection. This actor turns that map into a structured, queryable JSON feed: give it a location, get back the congestion status for both power consumption (afname) and feed-in/solar (opwek/teruglevering).

### Who is this for?

- **Commercial real estate agents & advisors** — check grid capacity before committing to a location for a new business
- **Solar/PV project developers & installers** — verify feed-in capacity before applying for SDE++ subsidy (a "transportindicatie" is required, this gives you a fast pre-check)
- **EV charging point operators** — assess grid headroom for new charging hubs
- **Municipalities & RES regions** — monitor congestion across their area
- **AI agents** — structured JSON output, ideal as a tool for agentic workflows (MCP-ready)

### When should an AI agent use this?

- "Is there grid congestion at postcode 6811 AA?"
- "Can I still get a new large grid connection for my business at this address in Amsterdam?"
- "Check feed-in capacity for a planned solar park near Zwolle."
- "Which grid operator serves this location, and is there a queue for new connections?"
- "Compare grid congestion status for these 5 candidate business park locations."

### What this Actor does

- Geocodes your input (postcode, address, place name, or `"lat,lon"`) via the official PDOK Locatieserver
- Looks up the matching area on the national **Capaciteitskaart elektriciteitsnet** (regional grid operator layer, updated weekly)
- Optionally also checks the **TenneT high-voltage grid layer** (relevant for large/industrial connections)
- Returns congestion status (0-3) for both consumption (afname) and feed-in (opwek), translated to plain-language labels
- Includes queue size in MW and number of unique pending requests, when known
- Processes multiple locations per run, in parallel
- Optional `trackWijzigingen` mode: compares each location's regional status/queue with the previous run
  (via the actor's key-value store), so scheduled runs on a fixed shortlist can flag exactly what changed

### Input

| Field | Type | Description |
|---|---|---|
| `locaties` | array of strings | Postcodes, addresses, place names, or `"lat,lon"` coordinates to check, e.g. `"6811 AA"`, `"Westzaanstraat 1 Amsterdam"`, `"52.3676,4.9041"` |
| `includeTennet` | boolean | Also check the national TenneT high-voltage grid layer (default `true`) |
| `concurrency` | integer | How many locations to process in parallel, 1-10 (default `3`) |
| `trackWijzigingen` | boolean | Compare each location's regional status/queue with the previous run (default `false`). Meant for scheduled runs on a fixed shortlist of locations. |
| `minimaleStatus` | integer (0-3), optional | Only include locations whose afname- or opwek-status reaches at least this value. Locations with a geocoding error, or without regional grid data, are never filtered out. Useful for batch runs where you only want to see the problematic locations |

### Output

One result per input location:

```json
{
  "invoer": "1012 NX Amsterdam",
  "gevonden": true,
  "fout": null,
  "weergavenaam": "Gapersteeg, 1012NX Amsterdam",
  "postcode": "1012NX",
  "gemeente": "Amsterdam",
  "provincie": "Noord-Holland",
  "lat": 52.37146235,
  "lon": 4.89234288,
  "regionaal": {
    "netbeheerder": "Liander",
    "netbeheerderNamen": ["Liander"],
    "netbeheerderVervolgstapUrls": ["https://transportindicatie.web.liander.nl/"],
    "voedingsgebied": "OS MARNIXSTRAAT 10-1i",
    "statusAfname": 2,
    "statusAfnameLabel": "Onvoldoende ruimte, gebied in onderzoek met wachtrij",
    "statusOpwek": 0,
    "statusOpwekLabel": "Voldoende ruimte, geen wachtrij",
    "wachtrijAfnameMw": null,
    "wachtrijInvoedingMw": null,
    "uniekeVerzoekenAfname": null,
    "uniekeVerzoekenInvoeding": null
  },
  "tennet": {
    "congestiegebiedAfname": "Noord-Holland",
    "congestiegebiedOpwek": "Noord-Holland",
    "statusAfname": 3,
    "statusAfnameLabel": "Geen ruimte, tekort aan transportcapaciteit met wachtrij",
    "statusOpwek": 0,
    "statusOpwekLabel": "Voldoende ruimte, geen wachtrij",
    "jaartalOpgelostAfname": 2036,
    "jaartalOpgelostInvoeding": null,
    "wachtrijAfnameMw": 4390,
    "wachtrijInvoedingMw": null
  },
  "bron": "Netbeheer Nederland — Landelijke Capaciteitskaart (capaciteitskaart.netbeheernederland.nl)",
  "gewijzigdSindsVorigeRun": null,
  "vorigeStatusAfname": null,
  "vorigeStatusOpwek": null,
  "vorigeWachtrijAfnameMw": null
}
````

- **Status codes:** `0` = sufficient room, no queue · `1` = limited room, no queue · `2` = insufficient room, area under investigation with a queue · `3` = no room, shortage with a queue
- **`regionaal`** reflects your local grid operator's medium-voltage network (relevant for most new/upgraded connections above 3x80A); **`tennet`** reflects the national high-voltage network (relevant mainly for large industrial connections and utility-scale solar/wind)
- **`netbeheerderVervolgstapUrls`** gives a next-step link (transport-indication request page) per name in `netbeheerderNamen`, for grid operators with a manually verified URL. `null` at a position means no reliably verifiable URL is available for that operator (currently TenneT and Rendo — their pages blocked automated verification)
- If geocoding fails, `gevonden` is `false` and `fout` explains why — no partial/guessed results are returned

#### Batch summary (free extra dataset record)

Whenever the run checks 2 or more locations, one extra record with `"soort": "batch-samenvatting"` is pushed
to the dataset (no extra charge): counts per status code/grid operator/province, the average `wachtrijAfnameMw`
across locations that have one, and how many were filtered out by `minimaleStatus` — a quick portfolio-level
overview without aggregating the dataset yourself.

#### Change tracking (`trackWijzigingen`, optional, separately charged)

With `trackWijzigingen: true`, every location is compared with the previous run for the same raw input string:

- `gewijzigdSindsVorigeRun`: `null` (no previous run for this location, e.g. the first run), or `true`/`false`
- `vorigeStatusAfname` / `vorigeStatusOpwek` / `vorigeWachtrijAfnameMw`: the previous run's values, when available

This is meant for scheduled/recurring runs on a fixed shortlist of locations (business park candidates, solar
project sites) — you get a direct signal the moment something changes, instead of manually re-checking every
week.

### Use cases

**Pre-screen a shortlist of business park locations:**

```json
{
  "locaties": ["Bedrijvenpark De Kolk, Zwolle", "Industrieterrein Moerdijk", "6811 AA Arnhem"]
}
```

**Quick feed-in check for a solar project, skip the TenneT layer:**

```json
{
  "locaties": ["52.2, 5.9"],
  "includeTennet": false
}
```

### Pricing

This Actor uses Apify's Pay-Per-Event (PPE) pricing model.

- **Actor Start:** $0.00005 (Apify default)
- **locatie-resultaat:** $0.01 per location checked (includes geocoding, regional grid status, and TenneT status when enabled)
- **wijziging-gedetecteerd:** $0.03 extra, only with `trackWijzigingen` enabled and only when a change vs. the
  previous run is actually found

### Legal

- Data source: **Netbeheer Nederland's Landelijke Capaciteitskaart** (capaciteitskaart.netbeheernederland.nl), served via a public ArcGIS Feature Service maintained by Esri Nederland Content on behalf of Netbeheer Nederland. Updated weekly. No authentication required; the map's own export feature is explicitly built for external/GIS reuse.
- This is grid infrastructure/capacity data about geographic areas, not personal data — no GDPR concerns.
- The underlying map is **a snapshot, not a guarantee**. Netbeheer Nederland explicitly states you must contact your grid operator directly before making concrete investment plans. This actor is a fast pre-screening tool, not a substitute for an official "transportindicatie".
- Geocoding uses the official Dutch government **PDOK Locatieserver** (Kadaster/BZK), a free public service.

### FAQ

**Q: How current is the data?**
A: The underlying Capaciteitskaart is updated weekly (every Monday, per the source's own documentation).

**Q: What does a `null` queue value mean?**
A: The source reports `0`/`null` when no queue is registered at the regional grid operator — it does not always mean a shortage-free area, so always check the status code together with the queue field.

**Q: Does this cover all four regional grid operators?**
A: Yes — the `regionaal` layer covers all Dutch regional grid operators (Liander, Enexis, Stedin, Coteq, Westland Infra, Rendo) in a single unified feed, plus TenneT for the national high-voltage grid.

### Related Actors

- **[PDOK Locatieserver](https://apify.com/codeclouds/pdok-locatieserver)** — the same geocoding source this actor uses internally, useful if you need broader address/CBS-data lookups beyond grid congestion.
- **[NL Nieuwbouwvergunningen Monitor](https://apify.com/codeclouds/nl-nieuwbouwvergunningen-monitor)** — combine with this actor for a complete due-diligence picture on a new-build project: building-permit status alongside whether the grid connection at that location actually has capacity.
- **[NL Vergunningen Leadfeed](../nl-vergunningen-leadfeed)** — same idea for broader environmental-permit leads: cross-check a permitted location's grid congestion status before following up.

***

*Zoekwoorden: netcongestie, transportschaarste, capaciteitskaart elektriciteitsnet, netbeheerder check, wachtrij stroomnet, aansluiting elektriciteitsnet, netcongestie postcode, liander capaciteit.*

### Keywords

netcongestie, grid congestion, capaciteitskaart, netbeheer nederland, liander, enexis, stedin, tennet, electricity grid, solar feed-in, netherlands

### Changelog

#### 0.4.0

- Added `netbeheerderVervolgstapUrls`: a manually verified next-step link per grid operator name (Liander,
  Enexis, Stedin, Coteq, Westland Infra) for a transport-indication request. TenneT and Rendo are
  deliberately omitted — their pages blocked automated verification, and a guessed/possibly-outdated link is
  worse than none. No pricing change.
- Added `minimaleStatus` input: only include locations whose afname- or opwek-status reaches at least this
  value, for batch runs that only need to see the problematic locations. Never filters out a
  geocoding-error or no-data result. Lowers the number of `locatie-resultaat` charges for clients who use it.
- Added a free `batch-samenvatting` dataset record for batch runs (2+ locations): counts per status
  code/grid operator/province, average queue MW, and how many locations were filtered out. No pricing change.
- Added Related Actors cross-links to NL Nieuwbouwvergunningen Monitor and NL Vergunningen Leadfeed, now that
  both are live.

#### 0.3.2 - Bugfix

- Change-detection snapshot is now merged with the previous run's snapshot instead of being fully replaced.
  Previously, a location that failed geocoding or was temporarily left out of the input list would silently
  lose its tracked history, causing the next run to see it as "first time" instead of a real comparison.
- `locatie-resultaat` is no longer charged for a lookup that returns no result (geocoding failure or
  exception) — only a genuinely resolved location is billed.

#### 0.3.1 - Bugfix

- Fixed `trackWijzigingen` never seeing prior-run state (`gewijzigdSindsVorigeRun` always `null`): the actor
  was reading/writing its snapshot to Apify's per-Run *default* key-value store, which is not shared between
  separate runs. Now uses a named, persistent key-value store. A new baseline will be captured on the next run.

#### 0.3.0

- Added `trackWijzigingen` mode: compares each location's regional status/queue with the previous run (via
  the actor's key-value store, keyed on the raw location string). New fields `gewijzigdSindsVorigeRun`,
  `vorigeStatusAfname`, `vorigeStatusOpwek`, `vorigeWachtrijAfnameMw`. New charged event
  `wijziging-gedetecteerd` ($0.03), confirmed by the user (2026-07-14).

#### 0.2.0

- Added `netbeheerderNamen` — splits the raw `netbeheerder` field (which can be comma-separated for
  overlap areas, e.g. `"Coteq, Enexis"`, confirmed live 2026-07-14) into an array for easier per-operator
  filtering/matching. No pricing change.

#### 0.1.0

- Initial release: postcode/address-level grid congestion lookup against the regional and TenneT capaciteitskaart layers.

# Actor input Schema

## `locaties` (type: `array`):

Postcodes, addresses, place names, or "lat,lon" coordinates to check, e.g. "6811 AA", "Westzaanstraat 1 Amsterdam", "52.3676,4.9041".

## `includeTennet` (type: `boolean`):

Also check the national TenneT high-voltage grid layer (relevant for large/industrial grid connections), in addition to the regional grid operator layer.

## `concurrency` (type: `integer`):

How many locations to process in parallel (1-10).

## `trackWijzigingen` (type: `boolean`):

Compare each location's regional status/queue with the previous run (via the actor's key-value store, keyed on the raw location string). Ideal for scheduled runs on a fixed shortlist of locations. Charges the extra wijziging-gedetecteerd event when a change is found. On the very first run for a given location (no stored snapshot yet), no change is detected or charged — a baseline is simply recorded. Uses a shared, persistent key-value store baseline that is also updated by scheduled monitoring runs — an ad-hoc call in between can overwrite that baseline.

## `minimaleStatus` (type: `integer`):

Optional: only include locations whose afname- or opwek-status reaches at least this value (0-3) in the output. Locations with a geocoding error, or without regional grid data, are never filtered out. Useful for batch runs where you only want to see the problematic locations. Leave empty for no filter.

## Actor input object example

```json
{
  "locaties": [
    "1012 NX Amsterdam"
  ],
  "includeTennet": true,
  "concurrency": 3,
  "trackWijzigingen": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "locaties": [
        "1012 NX Amsterdam"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/nl-netcongestie-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 = { "locaties": ["1012 NX Amsterdam"] }

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/nl-netcongestie-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 '{
  "locaties": [
    "1012 NX Amsterdam"
  ]
}' |
apify call codeclouds/nl-netcongestie-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NL Netcongestie Monitor (Grid Congestion Checker)",
        "description": "Checkt per postcode/adres of er netcongestie is op het Nederlandse elektriciteitsnet, via de officiele landelijke Capaciteitskaart van Netbeheer Nederland en TenneT.",
        "version": "0.1",
        "x-build-id": "MuecxYbHqTfUhlxiE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~nl-netcongestie-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-nl-netcongestie-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/codeclouds~nl-netcongestie-monitor/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-nl-netcongestie-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/codeclouds~nl-netcongestie-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-nl-netcongestie-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",
                "required": [
                    "locaties"
                ],
                "properties": {
                    "locaties": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Postcodes, addresses, place names, or \"lat,lon\" coordinates to check, e.g. \"6811 AA\", \"Westzaanstraat 1 Amsterdam\", \"52.3676,4.9041\".",
                        "default": [
                            "1012 NX Amsterdam"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeTennet": {
                        "title": "Include TenneT high-voltage grid layer",
                        "type": "boolean",
                        "description": "Also check the national TenneT high-voltage grid layer (relevant for large/industrial grid connections), in addition to the regional grid operator layer.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many locations to process in parallel (1-10).",
                        "default": 3
                    },
                    "trackWijzigingen": {
                        "title": "Track changes since previous run",
                        "type": "boolean",
                        "description": "Compare each location's regional status/queue with the previous run (via the actor's key-value store, keyed on the raw location string). Ideal for scheduled runs on a fixed shortlist of locations. Charges the extra wijziging-gedetecteerd event when a change is found. On the very first run for a given location (no stored snapshot yet), no change is detected or charged — a baseline is simply recorded. Uses a shared, persistent key-value store baseline that is also updated by scheduled monitoring runs — an ad-hoc call in between can overwrite that baseline.",
                        "default": false
                    },
                    "minimaleStatus": {
                        "title": "Minimum status threshold (batch prioritization)",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Optional: only include locations whose afname- or opwek-status reaches at least this value (0-3) in the output. Locations with a geocoding error, or without regional grid data, are never filtered out. Useful for batch runs where you only want to see the problematic locations. Leave empty for no filter."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```