# WOZ Waardeloket — Official Dutch Property Valuations (`unfenced-group/woz-waardeloket-scraper`) Actor

Retrieve official WOZ property values, full history with CAGR, land area, cadastral parcels and BAG building data for any Dutch address. Bulk-capable. No proxy or API key required.

- **URL**: https://apify.com/unfenced-group/woz-waardeloket-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 woz results

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

## WOZ Waardeloket Scraper

![WOZ Waardeloket Scraper](https://iili.io/By437Tu.png)

Retrieve official Dutch WOZ property valuations from [wozwaardeloket.nl](https://www.wozwaardeloket.nl) — the government database covering every taxable property in the Netherlands. Supply a list of addresses and get back the full WOZ history, compound growth rate, land area, cadastral parcels, and BAG building data in one structured dataset. No API key required. **No proxy needed — runs entirely on public government APIs.**

---

### Why this scraper?

#### 🏛️ Official government data — not scraped estimates
WOZ values are set by Dutch municipalities and published by Kadaster. This scraper reads from the same authoritative source the government uses. The data includes every assessment year on record (typically 12–15 years), so you see the full price trajectory — not just the current value.

#### 📈 Growth analysis built in — CAGR and year-over-year per entry
Most WOZ tools return a flat list of values. This scraper calculates the compound annual growth rate (`wozGrowthCagr`) across the full history, and adds a `yoyGrowthPct` field to each assessment year so you can immediately identify which years saw the sharpest increases — without writing any additional code.

#### 🗺️ Cadastral parcels included — competitor does not provide this
Each result includes the cadastral parcel references (`kadastralePercelen`) linked to the address — municipality code, section letter, and parcel number. This is the data you need for further Kadaster lookups, mortgage research, or title verification. The only comparable actor on the Apify Store does not return this.

#### 📍 Full neighbourhood context — buurt, wijk, gemeente, provincie
Every record includes the CBS neighbourhood code (`buurtcode`), district code (`wijkcode`), municipality, and province — pulled directly from the PDOK register. No post-processing or third-party geocoding required. Use these codes to aggregate WOZ data by neighbourhood or compare growth rates across districts.

#### 🏗️ Building-level data from BAG — units, floor area, build year
The scraper cross-references the BAG building register to return the construction year (`bouwjaar`), floor area (`oppervlakte`), permitted use (`gebruiksdoel`), and the number of units in the building (`aantalVerblijfsobjecten`). A flat that returns 199 units is an apartment block — that context matters for valuation.

#### ⚡ No browser, no proxy — fast and cost-efficient
The only comparable actor on the Apify Store uses a stealth browser to bypass access controls. This scraper uses the underlying public government APIs directly — no browser overhead, no residential proxy cost. A batch of 100 addresses typically completes in under 30 seconds.

---

### Input parameters

Two input modes are supported. Use whichever fits your workflow.

**Single address (flat fields):**

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `streetAddress` | string | Street name and house number, e.g. `"Kloosterlaan 33"` | — |
| `postcode` | string | Dutch postcode, e.g. `"1216NH"` — spaces allowed | — |
| `city` | string | City name, e.g. `"Hilversum"` — recommended | — |

**Bulk lookup (addresses array):**

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `addresses` | array | List of address objects — each requires `streetAddress` and `postcode` | — |
| `addresses[].streetAddress` | string | Street name with house number, e.g. `"Kloosterlaan 33"` | — |
| `addresses[].postcode` | string | Dutch postcode, e.g. `"1216NH"` | — |
| `addresses[].city` | string | City name — recommended for disambiguation | — |
| `addresses[].huisletter` | string | House letter suffix, e.g. `"A"` or `"B"` | — |
| `addresses[].toevoeging` | string | House number extension, e.g. `"hoog"` or `"bis"` | — |

**Common options:**

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `maxConcurrency` | integer | Parallel processing — relevant for bulk runs | `10` |
| `skipBag` | boolean | Skip BAG building lookup — ~40% faster, WOZ values only | `false` |

> **Postcode tolerance:** if the supplied postcode does not match the BAG register (e.g. `"1016BP"` instead of `"1016BR"`), the scraper automatically falls back to city-based resolution. The corrected postcode appears in the output.

> **Non-residential objects:** government buildings, public infrastructure, and most commercial property have no WOZ registration. These return `wozLatestValue: null` and `isResidential: false` — this is correct, not an error.

---

### Output schema

```json
{
  "inputAddress":          { "streetAddress": "Kloosterlaan 33", "postcode": "1216NH", "city": "Hilversum" },
  "address":               "Kloosterlaan 33, 1216NH Hilversum",
  "streetAddress":         "Kloosterlaan 33",
  "postcode":              "1216NH",
  "city":                  "Hilversum",
  "gemeente":              "Hilversum",
  "gemeentecode":          "0402",
  "provincie":             "Noord-Holland",
  "provinciecode":         "PV27",
  "buurt":                 "Kerkelanden",
  "buurtcode":             "BU04020304",
  "wijk":                  "Zuidwest",
  "wijkcode":              "WK040203",
  "lat":                   52.22007594,
  "lon":                   5.13386319,
  "nummeraanduidingId":    "0402200001552236",
  "adresseerbaarobjectId": "0402010001552237",
  "pandId":                "0402100001486583",
  "isResidential":         true,
  "wozObjectnummer":       40200018608,
  "wozLatestValue":        450000,
  "wozLatestYear":         2025,
  "wozGrowthCagr":         7.1,
  "wozHistoryYears":       12,
  "wozValues": [
    { "peildatum": "2025-01-01", "peiljaar": 2025, "waarde": 450000, "yoyGrowthPct": 11.9 },
    { "peildatum": "2024-01-01", "peiljaar": 2024, "waarde": 402000, "yoyGrowthPct":  4.7 },
    { "peildatum": "2023-01-01", "peiljaar": 2023, "waarde": 384000, "yoyGrowthPct":  4.3 },
    { "peildatum": "2022-01-01", "peiljaar": 2022, "waarde": 368000, "yoyGrowthPct": 12.3 },
    { "peildatum": "2021-01-01", "peiljaar": 2021, "waarde": 328000, "yoyGrowthPct": 11.9 }
  ],
  "grondoppervlakte":      146,
  "kadastralePercelen": [
    { "gemeente": "HVS00", "sectie": "H", "perceel": "4212" },
    { "gemeente": "HVS00", "sectie": "H", "perceel": "3454" }
  ],
  "locatieomschrijving":   null,
  "building": {
    "bouwjaar":                1971,
    "oppervlakte":             143,
    "oppervlakteMin":          143,
    "oppervlakteMax":          143,
    "gebruiksdoel":            "woonfunctie",
    "status":                  "Verblijfsobject in gebruik",
    "pandStatus":              "Pand in gebruik",
    "aantalVerblijfsobjecten": 1
  },
  "scrapeTimestamp":       "2026-05-19T13:30:00.000Z"
}
````

On address resolution failure:

```json
{
  "inputAddress": { "streetAddress": "Onbestaandestraat 999", "postcode": "9999ZZ" },
  "address":      "Onbestaandestraat 999, 9999ZZ",
  "postcode":     "9999ZZ",
  "error":        "ADDRESS_NOT_FOUND",
  "scrapeTimestamp": "2026-05-19T13:30:00.000Z"
}
```

***

### Examples

**Single address — flat input (simplest):**

```json
{
  "streetAddress": "Kloosterlaan 33",
  "postcode":      "1216NH",
  "city":          "Hilversum"
}
```

**Single address — array input:**

```json
{
  "addresses": [
    { "streetAddress": "Kloosterlaan 33", "postcode": "1216NH", "city": "Hilversum" }
  ]
}
```

**Bulk residential portfolio — WOZ values only, maximum speed:**

```json
{
  "addresses": [
    { "streetAddress": "Nassaukade 5-2",      "postcode": "1052CE", "city": "Amsterdam" },
    { "streetAddress": "Fahrenheitstraat 10",  "postcode": "2561BS", "city": "Den Haag"  },
    { "streetAddress": "Bergwegplantsoen 100", "postcode": "3037SK", "city": "Rotterdam" },
    { "streetAddress": "Vrijheidslaan 22",     "postcode": "9726AK", "city": "Groningen" }
  ],
  "maxConcurrency": 10,
  "skipBag": true
}
```

**Apartment with house letter — includes full building context:**

```json
{
  "addresses": [
    { "streetAddress": "Bergweg 100", "postcode": "3036SB", "city": "Rotterdam", "huisletter": "A" }
  ],
  "skipBag": false
}
```

**Large-scale enrichment run — mixed residential and commercial:**

```json
{
  "addresses": [
    { "streetAddress": "Herengracht 182",   "postcode": "1016BP", "city": "Amsterdam" },
    { "streetAddress": "Coolsingel 40",     "postcode": "3011AD", "city": "Rotterdam" },
    { "streetAddress": "Stationsplein 1",   "postcode": "3511ED", "city": "Utrecht"   }
  ],
  "maxConcurrency": 20
}
```

***

### 💰 Pricing

**$1.49 per 1,000 results** — you only pay for successfully retrieved addresses. Failed lookups on invalid addresses are still counted (one result is always written per input address), but no proxy or compute surcharges are added.

| Results | Cost |
|---------|------|
| 100 | ~$0.15 |
| 1,000 | ~$1.49 |
| 10,000 | ~$14.90 |
| 100,000 | ~$149.00 |

> The only comparable actor on the Apify Store charges **$8.50 per 1,000 results** as a base rate, plus separate per-event charges for BAG data, retries, proxy usage, and debug screenshots. At 10,000 results that actor typically costs $120–$200+ depending on usage. This scraper costs $14.90 for the same volume — with more output fields.

Use the `maxConcurrency` setting to control throughput. There is no built-in `maxResults` cap because the input is address-based — you control the volume by the number of addresses you supply.

***

### Performance

| Run size | Time | Notes |
|----------|------|-------|
| 10 addresses | ~6s | Including BAG lookup |
| 10 addresses | ~3s | `skipBag: true` |
| 100 addresses | ~30s | Concurrency 10 |
| 1,000 addresses | ~5 min | Concurrency 10 |
| 10,000 addresses | ~50 min | Concurrency 20 |

***

### Comparison with nocodeventure/woz-api-waardeloket-ppe

| Feature | This scraper | nocodeventure |
|---------|-------------|---------------|
| Base price | **$1.49 / 1,000** | $8.50 / 1,000 + events |
| BAG data charge | included | extra per-event charge |
| Proxy surcharge | none | extra per-event charge |
| Retry charge | none | extra per-event charge |
| Proxy required | **none** | residential (browser) |
| `kadastralePercelen` | ✅ | ❌ |
| `wozGrowthCagr` | ✅ | ❌ |
| Year-over-year % per entry | ✅ | ❌ |
| Buurt / wijk / provincie | ✅ | ❌ |
| `aantalVerblijfsobjecten` | ✅ | ❌ |
| `isResidential` flag | ✅ | ❌ |
| `huisletter` / `toevoeging` input | ✅ | ❌ |
| Postcode fallback on typos | ✅ | ❌ |
| Speed (100 addresses) | ~30s | ~10–20 min |

***

### Known limitations

- **Non-residential objects:** WOZ values are only published for objects registered in the Dutch WOZ system — primarily owner-occupied residential property and commercial real estate with a municipality assessment. Government buildings (Binnenhof, ministries), public infrastructure, and many rental properties return `wozLatestValue: null`. This is a limitation of the source data, not the scraper.
- **Rental property:** Rental housing is often registered under a housing corporation, not as individual WOZ objects. These addresses may return `wozLatestValue: null` even for residential buildings.
- **New construction:** Properties built within the last 12–18 months may not yet have a WOZ assessment. They will still resolve correctly with full BAG building data.
- **Address format:** The BAG register is the reference — addresses that do not exist in the BAG (demolished buildings, future developments) cannot be resolved.

***

### Technical details

- **Sources:** Dutch government registers — WOZ Waardeloket (Kadaster), PDOK Locatieserver, PDOK BAG WFS
- **Method:** Direct REST API calls — no browser, no proxy
- **Memory:** 256 MB
- **Retry:** Automatic exponential backoff on server errors, up to 3 attempts per request
- **Postcode fallback:** Automatic retry with city-only resolution when postcode yields no results
- **Concurrency:** Configurable, default 10, max 20

***

### Additional services

Need a custom actor, additional filters, scheduled runs, or integration support?
Send an email to <info@unfencedgroup.nl> — we build on request.

***

*Built by [unfenced-group](https://apify.com/unfenced-group) · Issues? Open a ticket or send a message.*

# Actor input Schema

## `streetAddress` (type: `string`):

Street name and house number, e.g. "Kloosterlaan 33". Required together with postcode for a single-address run. Leave blank when using the addresses array below.

## `postcode` (type: `string`):

Dutch postcode, e.g. "1216NH". Required together with streetAddress. Spaces are allowed.

## `city` (type: `string`):

City name, e.g. "Hilversum". Recommended — improves accuracy and enables automatic postcode correction.

## `addresses` (type: `array`):

For bulk lookups: list of address objects. Each entry needs streetAddress and postcode. When using this field, leave the single-address fields above blank.

## `maxConcurrency` (type: `integer`):

Number of addresses processed in parallel. Increase for large bulk runs.

## `skipBag` (type: `boolean`):

Skip the PDOK BAG lookup (bouwjaar, oppervlakte, aantalVerblijfsobjecten). About 40% faster when you only need WOZ values.

## Actor input object example

```json
{
  "streetAddress": "Kloosterlaan 33",
  "postcode": "1216NH",
  "city": "Hilversum",
  "addresses": [],
  "maxConcurrency": 10,
  "skipBag": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "streetAddress": "Kloosterlaan 33",
    "postcode": "1216NH",
    "city": "Hilversum",
    "addresses": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/woz-waardeloket-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "streetAddress": "Kloosterlaan 33",
    "postcode": "1216NH",
    "city": "Hilversum",
    "addresses": [],
}

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/woz-waardeloket-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "streetAddress": "Kloosterlaan 33",
  "postcode": "1216NH",
  "city": "Hilversum",
  "addresses": []
}' |
apify call unfenced-group/woz-waardeloket-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=unfenced-group/woz-waardeloket-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WOZ Waardeloket — Official Dutch Property Valuations",
        "description": "Retrieve official WOZ property values, full history with CAGR, land area, cadastral parcels and BAG building data for any Dutch address. Bulk-capable. No proxy or API key required.",
        "version": "2.0",
        "x-build-id": "odiSz3vIeG62loyJW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~woz-waardeloket-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-woz-waardeloket-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/unfenced-group~woz-waardeloket-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-woz-waardeloket-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/unfenced-group~woz-waardeloket-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-woz-waardeloket-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "streetAddress": {
                        "title": "Street address",
                        "type": "string",
                        "description": "Street name and house number, e.g. \"Kloosterlaan 33\". Required together with postcode for a single-address run. Leave blank when using the addresses array below."
                    },
                    "postcode": {
                        "title": "Postcode",
                        "type": "string",
                        "description": "Dutch postcode, e.g. \"1216NH\". Required together with streetAddress. Spaces are allowed."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, e.g. \"Hilversum\". Recommended — improves accuracy and enables automatic postcode correction."
                    },
                    "addresses": {
                        "title": "Addresses (bulk)",
                        "type": "array",
                        "description": "For bulk lookups: list of address objects. Each entry needs streetAddress and postcode. When using this field, leave the single-address fields above blank."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of addresses processed in parallel. Increase for large bulk runs.",
                        "default": 10
                    },
                    "skipBag": {
                        "title": "Skip BAG building data",
                        "type": "boolean",
                        "description": "Skip the PDOK BAG lookup (bouwjaar, oppervlakte, aantalVerblijfsobjecten). About 40% faster when you only need WOZ values.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
