# Dutch Address & BAG Registry Scraper (`parseforge/pdok-bag-nl-scraper`) Actor

Scrape Dutch addresses from the BAG registry. Get street names, house numbers, postal codes, cities, provinces, GPS coordinates, and linked parcel IDs for every address in the Netherlands. Ideal for real estate and geocoding.

- **URL**: https://apify.com/parseforge/pdok-bag-nl-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🇳🇱 PDOK BAG Dutch Address Registry Scraper

> 🚀 Search the official Dutch address registry (BAG) and collect structured records with full addresses, GPS coordinates, municipalities, provinces, neighborhoods, and districts. Filter by type and free-text query.

> 🕒 Last updated: 2026-04-17

The Netherlands maintains one of the cleanest open address registries in the world through PDOK BAG. This Actor searches that registry and returns structured records with street names, house numbers, postal codes, cities, municipalities, provinces, districts, neighborhoods, water authorities, GPS coordinates, and BAG identifiers. You can search by address, postcode, street name, or city name, and filter by eight different object types.

Real estate platforms enriching listings, delivery companies resolving addresses to coordinates, govtech teams building address autocomplete, and GIS analysts mapping administrative boundaries all depend on clean, validated Dutch address data. This tool gives you bulk access to the official registry in seconds, with no coding or manual browsing required.

| Target | PDOK BAG (Dutch Address and Building Registry) |
|--------|-------------------------------|
| Use Cases | Address validation, geocoding, real estate data enrichment, delivery logistics, GIS mapping |

---

### 📋 What it does

- 🏠 **Full Dutch addresses.** Street name, house number, letter suffix, postal code, and city for every record.
- 📍 **GPS coordinates.** WGS84 latitude and longitude for geocoding and mapping.
- 🗺️ **Administrative hierarchy.** Municipality, province, district (wijk), and neighborhood (buurt).
- 🏷️ **8 object types.** Search addresses, streets, postcodes, cities, municipalities, provinces, districts, or neighborhoods.
- 🆔 **BAG identifiers.** Addressable object IDs and numbering IDs for integration with other Dutch registries.

Each record includes the object type, display name, street, house number, postal code, city, neighborhood, district, municipality (with code), province (with abbreviation), water authority, latitude, longitude, BAG IDs, source, and scrape timestamp.

> 💡 **Why it matters:** Manually looking up Dutch addresses one by one in the PDOK interface is painfully slow for any bulk task. This Actor collects thousands of validated records with coordinates and administrative data in a single run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>"Amsterdam"</code></td><td>Address, street, postcode, or city name. Examples: "Dam 1 Amsterdam", "1012JS", "Rotterdam".</td></tr>
<tr><td><code>type</code></td><td>string</td><td><code>"adres"</code></td><td>Filter by object type: adres, weg, postcode, woonplaats, gemeente, provincie, wijk, or buurt.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Maximum records to return. Free users limited to 10. Paid users up to 1,000,000.</td></tr>
</tbody>
</table>

**Example: Addresses in Amsterdam.**

```json
{
    "searchQuery": "Amsterdam",
    "type": "adres",
    "maxItems": 100
}
````

**Example: All postcodes matching "1012".**

```json
{
    "searchQuery": "1012",
    "type": "postcode",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** The PDOK BAG registry is updated continuously by Dutch municipalities. Every run returns the latest published data. The API is public and does not require authentication.

***

### 📊 Output

Each record contains **20+ fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `type` | string | `"adres"` |
| 📋 `displayName` | string | `"Dam 1, 1012JS Amsterdam"` |
| 🛣️ `street` | string | `"Dam"` |
| 🔢 `houseNumber` | integer | `1` |
| 📮 `postalCode` | string | `"1012JS"` |
| 🏙️ `city` | string | `"Amsterdam"` |
| 🏘️ `neighborhood` | string | `"Burgwallen-Oude Zijde"` |
| 🏢 `district` | string | `"Centrum-Oost"` |
| 🏛️ `municipality` | string | `"Amsterdam"` |
| 🗺️ `province` | string | `"Noord-Holland"` |
| 📍 `latitude` | number | `52.37273` |
| 📍 `longitude` | number | `4.89371` |
| 💧 `waterAuthority` | string | `"Waterschap Amstel, Gooi en Vecht"` |
| 🆔 `addressableObjectId` | string | `"0363010000123456"` |

#### 📦 Sample records

<details>
<summary><strong>🏠 Address record in Amsterdam</strong></summary>

```json
{
    "type": "adres",
    "displayName": "Dam 1, 1012JS Amsterdam",
    "street": "Dam",
    "houseNumber": 1,
    "postalCode": "1012JS",
    "city": "Amsterdam",
    "neighborhood": "Burgwallen-Oude Zijde",
    "district": "Centrum-Oost",
    "municipality": "Amsterdam",
    "municipalityCode": "0363",
    "province": "Noord-Holland",
    "provinceAbbr": "NH",
    "waterAuthority": "Waterschap Amstel, Gooi en Vecht",
    "latitude": 52.37273,
    "longitude": 4.89371,
    "id": "adr-abc123",
    "addressableObjectId": "0363010000123456",
    "source": "BAG",
    "scrapedAt": "2026-04-10T12:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🛣️ Street record in Rotterdam</strong></summary>

```json
{
    "type": "weg",
    "displayName": "Coolsingel, Rotterdam",
    "street": "Coolsingel",
    "city": "Rotterdam",
    "municipality": "Rotterdam",
    "municipalityCode": "0599",
    "province": "Zuid-Holland",
    "provinceAbbr": "ZH",
    "latitude": 51.92125,
    "longitude": 4.47830,
    "source": "BAG",
    "scrapedAt": "2026-04-10T12:05:00.000Z"
}
```

</details>

<details>
<summary><strong>🏘️ Neighborhood record</strong></summary>

```json
{
    "type": "buurt",
    "displayName": "Jordaan, Amsterdam",
    "neighborhood": "Jordaan",
    "district": "Centrum-West",
    "municipality": "Amsterdam",
    "municipalityCode": "0363",
    "province": "Noord-Holland",
    "provinceAbbr": "NH",
    "latitude": 52.37488,
    "longitude": 4.88100,
    "source": "BAG",
    "scrapedAt": "2026-04-10T12:10:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏠 | **Official BAG data.** Direct access to the Dutch government's address registry. |
| 🏷️ | **8 object types.** Addresses, streets, postcodes, cities, municipalities, provinces, districts, and neighborhoods. |
| 📍 | **GPS coordinates.** WGS84 latitude and longitude for every matched record. |
| 🗺️ | **Full administrative hierarchy.** Neighborhood through province in every record. |
| 🆔 | **BAG identifiers.** Official IDs for integration with other Dutch registries. |
| ⚡ | **Fast lookups.** Hundreds of records returned in seconds. |
| 📊 | **Multiple exports.** Download as CSV, Excel, JSON, or XML. |

> The Dutch BAG registry contains over 9 million address records, covering every building and address in the Netherlands with continuous updates from all 342 municipalities.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ PDOK BAG Scraper** *(this Actor)* | $5 free credit, then pay-per-use | All NL addresses | **Live per run** | ⚡ 2 min |
| Manual PDOK search | Free | Full registry | Manual | 🕐 Hours |
| PDOK API integration | Free | Full registry | Per request | 🔧 2-4 hours |
| Third-party geocoding services | $50-500/mo | Varies | Per request | 📋 30 min |

Pick this Actor when you need bulk Dutch address data with administrative boundaries and coordinates without building your own PDOK API integration.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the PDOK BAG Dutch Address Registry Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a search query, select an object type, and set your max items.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏠 Real Estate

- Enrich property listings with validated addresses
- Add GPS coordinates for map-based search
- Pull neighborhood and district data for listings
- Validate customer-entered addresses against BAG

</td>
<td width="50%" valign="top">

#### 🚚 Logistics and Delivery

- Resolve delivery addresses to GPS coordinates
- Build route planning datasets with validated addresses
- Geocode customer databases in bulk
- Validate postal codes against official records

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🏛️ Government and Civic Tech

- Build address autocomplete for Dutch forms
- Integrate BAG data into municipal applications
- Map administrative boundaries by district and neighborhood
- Generate reports by municipality or province

</td>
<td width="50%" valign="top">

#### 📊 Market Research and GIS

- Count addresses per neighborhood for density analysis
- Map commercial areas by postal code
- Study geographic distribution of building types
- Build datasets for spatial analysis tools

</td>
</tr>
</table>

***

### 🔌 Automating PDOK BAG Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Schedule monthly runs to keep your Dutch address database current with registry updates.

***

### ❓ Frequently Asked Questions

<details>
<summary><strong>🧩 How does it work?</strong></summary>
The Actor queries the PDOK Locatieserver API, which indexes the BAG registry. It paginates through results and returns structured records with all available fields.
</details>

<details>
<summary><strong>🇳🇱 What is BAG?</strong></summary>
BAG (Basisregistratie Adressen en Gebouwen) is the Dutch national registry of addresses and buildings, maintained by all 342 municipalities and published through PDOK.
</details>

<details>
<summary><strong>🏷️ What object types can I search?</strong></summary>
Addresses (adres), streets (weg), postcodes (postcode), cities (woonplaats), municipalities (gemeente), provinces (provincie), districts (wijk), and neighborhoods (buurt).
</details>

<details>
<summary><strong>📍 Are coordinates always included?</strong></summary>
Yes, for addresses and most object types. Coordinates are in WGS84 format (standard GPS latitude/longitude).
</details>

<details>
<summary><strong>🏢 What is the difference between wijk and buurt?</strong></summary>
A wijk (district) is larger than a buurt (neighborhood). A city contains districts, and each district contains multiple neighborhoods.
</details>

<details>
<summary><strong>🔄 How fresh is the data?</strong></summary>
BAG is updated continuously by Dutch municipalities. Every run returns the latest published data from the PDOK API.
</details>

<details>
<summary><strong>⚖️ Is it legal to use this data?</strong></summary>
Yes. BAG data is public government information, freely available through the PDOK API without authentication.
</details>

<details>
<summary><strong>💰 Can I use this commercially?</strong></summary>
Yes. BAG data is open government data and can be used in commercial applications without restrictions.
</details>

<details>
<summary><strong>💳 What happens after my free credit runs out?</strong></summary>
Subscribe to an Apify plan for continued usage. Free users are limited to 10 items per run.
</details>

<details>
<summary><strong>🔁 Can I schedule regular runs?</strong></summary>
Yes. Use Apify Schedules to trigger the Actor on any cron interval. Monthly runs are common for keeping address databases current.
</details>

<details>
<summary><strong>❌ What if a run fails?</strong></summary>
The Actor logs errors and exits cleanly. Common issues are network timeouts, which resolve on a retry.
</details>

<details>
<summary><strong>🆘 How do I get help?</strong></summary>
Open our contact form linked below to report issues, request features, or ask questions.
</details>

***

### 🔌 Integrate with any app

PDOK BAG Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🏠 REMAX Real Estate Scraper**](https://apify.com/parseforge/remax-scraper) - Scrape real estate listings with addresses and prices
- [**🏢 LoopNet Scraper**](https://apify.com/parseforge/loopnet-scraper) - Collect commercial real estate listings
- [**🏫 Greatschools Scraper**](https://apify.com/parseforge/greatschools-scraper) - School ratings and location data
- [**🅿️ ParkMe Parking Scraper**](https://apify.com/parseforge/parking-rate-scraper) - Real-time parking rates by location
- [**🏛️ GSA eLibrary Scraper**](https://apify.com/parseforge/gsa-elibrary-scraper) - Government contract data from GSA

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data scrapers and tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by PDOK, Kadaster, or the Dutch government. All trademarks mentioned are the property of their respective owners. Only publicly available data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `searchQuery` (type: `string`):

Address, street, postcode, or city name. Examples: 'Amsterdam', 'Dam 1 Amsterdam', '1012JS'.

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

Filter results by type.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "Amsterdam",
  "type": "adres"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10,
    "searchQuery": "Amsterdam"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/pdok-bag-nl-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 = {
    "maxItems": 10,
    "searchQuery": "Amsterdam",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/pdok-bag-nl-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 '{
  "maxItems": 10,
  "searchQuery": "Amsterdam"
}' |
apify call parseforge/pdok-bag-nl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dutch Address & BAG Registry Scraper",
        "description": "Scrape Dutch addresses from the BAG registry. Get street names, house numbers, postal codes, cities, provinces, GPS coordinates, and linked parcel IDs for every address in the Netherlands. Ideal for real estate and geocoding.",
        "version": "1.0",
        "x-build-id": "CKqqUcM5BxCHx64nR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~pdok-bag-nl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-pdok-bag-nl-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/parseforge~pdok-bag-nl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-pdok-bag-nl-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/parseforge~pdok-bag-nl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-pdok-bag-nl-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Address, street, postcode, or city name. Examples: 'Amsterdam', 'Dam 1 Amsterdam', '1012JS'."
                    },
                    "type": {
                        "title": "Object Type",
                        "enum": [
                            "",
                            "adres",
                            "weg",
                            "postcode",
                            "woonplaats",
                            "gemeente",
                            "provincie",
                            "wijk",
                            "buurt"
                        ],
                        "type": "string",
                        "description": "Filter results by type.",
                        "default": "adres"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
