# NL Bodemrisico Check — Bodemloket per Adres (`codeclouds/nl-bodemrisico-check`) Actor

Zoekt bodemverontreinigingslocaties (Wbb) uit het landelijke Bodemloket op voor een NL-adres/postcode/coordinaat, met risicolabels, bevoegd gezag en een expliciete dekkingsindicatie per regio. Voor aannemers en projectontwikkelaars vóór grondverzet.

- **URL**: https://apify.com/codeclouds/nl-bodemrisico-check.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 $6.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 Bodemrisico Check — Bodemloket per Adres 🇳🇱🟫

Check a Dutch address, postcode, place name, or coordinate against the **national Bodemloket** (soil
contamination register, Wbb locations) before starting excavation or groundwork — a fast, structured
pre-screen for soil contamination financial risk.

Excavation, land development and construction projects in the Netherlands can run into unexpected
remediation (sanering) costs if the site sits on a known or suspected soil contamination location under
the Wet bodembescherming (Wbb). The **Bodemloket** — a nationwide register maintained by the responsible
authorities (provinces, municipalities, environmental services) — publishes this data as a public GIS
service. This actor turns that into a simple per-address JSON lookup, including an honest "no coverage
data" signal so an empty result is never silently read as "no contamination".

### When should an AI agent use this?

- "Is there a known soil contamination location at this address before we start digging?"
- "Check these 5 candidate development sites for Bodemloket (Wbb) hits."
- "What's the remediation status of this former industrial site?"
- "Which authority is responsible for soil files at this location, and do they publish dossier data online?"
- "Screen a list of addresses for soil risk before submitting an excavation permit."

### What this Actor does

- Geocodes your input (postcode, address, place name, or `"lat,lon"`) via the official PDOK Locatieserver
- Runs a point-in-polygon lookup against the national **Bodemloket** ArcGIS service (Wbb-locaties layer)
- Returns every overlapping Wbb soil location, translated to plain-language Dutch labels (location type,
  contamination assessment, follow-up/remediation status)
- Looks up the responsible authority (bevoegd gezag) for the location
- Includes an explicit **coverage indicator**: whether the responsible authority publishes additional
  dossier data/web portal for this region — so "no result found" can be told apart from "no coverage data
  available for this region"
- Processes multiple locations per run, in parallel

### Who is this for?

- **Contractors & earthworks companies (grondverzetbedrijven)** — pre-screen a site before excavation to
  avoid unbudgeted remediation costs
- **Project developers** — early risk signal before acquiring or developing a plot
- **Environmental consultants** — quick first-pass check before commissioning a formal soil survey
  (bodemonderzoek)
- **AI agents** — structured JSON output, ideal as a tool for agentic due-diligence workflows

### Input

| Field | Type | Description |
|---|---|---|
| `locaties` | array of strings | Postcodes, addresses, place names, or `"lat,lon"` coordinates to check, e.g. `"Bathseweg 27, Rilland"`, `"4411BA"`, `"51.415,4.186"` |
| `concurrency` | integer | How many locations to process in parallel, 1-10 (default `3`) |
| `nabijheidsradiusMeter` | integer | Search for Wbb locations within this radius (meters) around the point instead of only exact overlap. `0` (default) = off, current point-only behaviour. Max `500`. |
| `monitorLocaties` | boolean | Compares each location's Wbb data with the previous run (via the actor's key-value store) and signals a new Wbb dossier or a changed `vervolgWbb` status. Default `false`. |

### Output

One result per input location:

```json
{
  "invoer": "Bathseweg 27, Rilland",
  "gevonden": true,
  "fout": null,
  "weergavenaam": "Bathseweg 27, 4411BA Rilland",
  "postcode": "4411BA",
  "gemeente": "Reimerswaal",
  "provincie": "Zeeland",
  "lat": 51.41533763,
  "lon": 4.18586885,
  "geocodingScore": 19.113255,
  "geocodingBetrouwbaarheid": "hoog",
  "wbbLocaties": [
    {
      "sikbId": null,
      "wbbDossierNummer": 126236372,
      "locatiecodeBevoegdGezag": "ZL070300019",
      "bisLoccode": "AA070302070",
      "typeCd": "21",
      "typeLabel": "Gesaneerd of in sanering",
      "vervolgWbb": "voldoende gesaneerd",
      "vervolgWbbLabel": "Voldoende gesaneerd",
      "statusver": null,
      "statusverLabel": "Geen beoordeling geregistreerd",
      "statusOordeel": "Onverdacht/Niet verontreinigd",
      "statusOordeelLabel": "Onverdacht / niet verontreinigd",
      "administrator": "Reimerswaal",
      "afstandMeter": null
    }
  ],
  "aantalWbbLocaties": 1,
  "bevoegdGezag": {
    "naam": "RUD Zeeland",
    "heeftWebsite": true,
    "websiteUrl": "https://zeeland.nazca4u.nl/Rapportage/",
    "heeftDossierdata": true
  },
  "dekkingBeschikbaar": false,
  "dekkingToelichting": "Geen dekkingsgegevens gevonden voor deze locatie in het Bodemloket — dit bevoegd gezag publiceert (nog) geen aanvullende dekkingsinformatie via deze laag.",
  "bron": "Bodemloket (Rijkswaterstaat, gis.gdngeoservices.nl/standalone/rest/services/blk_gdn/lks_blk_rd_v1)",
  "nabijheidsradiusToegepast": null
}
````

- **`geocodingBetrouwbaarheid`** (`"hoog"` / `"middel"` / `"laag"`) is an honest, best-effort classification
  based on PDOK's own relevance score (`geocodingScore`) — **not a guarantee**. PDOK's `/free` endpoint does
  fuzzy/best-effort matching and can return an irrelevant match even for a nonsensical address (see the FAQ
  below); `"laag"` means "verify this manually before relying on the result", not "this address doesn't exist".
  Direct `"lat,lon"` input is always `"hoog"` (no fuzzy matching involved).
- **`wbbLocaties`** is an array because multiple overlapping Wbb polygons can exist at a single point — an
  empty array is a **valid result**, not an error: it means no registered Wbb location overlaps this point.
- **`dekkingBeschikbaar`** reflects a *separate* Bodemloket layer (regional data-availability), not the
  Wbb-locaties layer itself. It can be `false` even when `wbbLocaties` is non-empty, and vice versa — always
  read both fields together. A `false` value means "this region's coverage/portal data isn't registered in
  this specific layer", **not** "this location has no contamination".
- Unknown/unmapped status or type codes are shown as `"Onbekende ... (code)"` with the raw code — labels are
  never guessed.
- If geocoding fails, `gevonden` is `false` and `fout` explains why.

#### Proximity radius (`nabijheidsradiusMeter`, optional, separately charged)

By default, only Wbb polygons that overlap the exact geocoded point are returned — a contamination location
20 meters away is missed. Set `nabijheidsradiusMeter` (e.g. `50`) to search within that radius instead, using
the same Bodemloket layer (no new data source). `nabijheidsradiusToegepast` reflects the radius actually used
(`null` in the default exact-point mode). Only charged the extra `nabijheidsradius-resultaat` event when at
least one location is found within the radius — a location for which nothing is found still costs only the
base `locatie-resultaat`.

In radius mode, each `wbbLocaties` item also gets an `afstandMeter` field (haversine distance in meters from
your point to the polygon's approximate centroid), and the array is sorted nearest-first — so with several
hits within range you immediately see which one is closest. `afstandMeter` stays `null` in the default
exact-point mode (the point is by definition inside the polygon, so distance isn't meaningful there).

#### Change monitoring (`monitorLocaties`, optional, separately charged)

With `monitorLocaties: true`, each location's Wbb data is compared with the previous run (via the actor's
key-value store, keyed on the normalized input string) — ideal for scheduled runs on a fixed shortlist of
locations (e.g. an active construction/remediation project):

```json
{
  "type": "wijziging_signaal",
  "invoer": "Bathseweg 27, Rilland",
  "signaalType": "status_gewijzigd",
  "wbbDossierNummer": 126236372,
  "vorigeVervolgWbb": "in sanering",
  "huidigeVervolgWbb": "voldoende gesaneerd"
}
```

`signaalType` is `"nieuw_dossier"` (a Wbb dossier that wasn't there last run) or `"status_gewijzigd"` (an
existing dossier's `vervolgWbb` value changed, e.g. from "in sanering" to "voldoende gesaneerd"). The very
first run for a location never produces a signal — there's nothing to compare against yet, not a guessed
"everything is new". Only charged the extra `wijziging-signaal` event when an actual change is detected.

#### Run summary (key-value store, free)

At the end of each run, a `RUN_SUMMARY` object is written to the actor's key-value store (visible in the Apify
Console run's storage tab) — no extra charge. It aggregates the whole batch: total locations processed, how
many had at least one Wbb location, how many errored, how many lacked `dekkingBeschikbaar`, and the
distribution of `geocodingBetrouwbaarheid` (hoog/middel/laag/onbekend). Useful for a portfolio-level overview
when screening dozens of addresses in one run, without scrolling through the full dataset.

### Use cases

**Pre-screen a shortlist of development sites:**

```json
{
  "locaties": ["Bathseweg 27, Rilland", "Industrieterrein Moerdijk", "52.09,5.12"]
}
```

**Single-address check before submitting an excavation permit:**

```json
{
  "locaties": ["4411BA"]
}
```

### Pricing

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

- **Actor Start:** $0.00005 (Apify default)
- **`locatie-resultaat`:** $0.006 per location checked (geocoding + Wbb-locaties lookup + bevoegd
  gezag + coverage indicator)
- **`nabijheidsradius-resultaat`:** $0.01 extra, only with `nabijheidsradiusMeter` enabled and only when at
  least one Wbb location is found within the radius
- **`wijziging-signaal`:** $0.012 extra, only with `monitorLocaties` enabled and only when an actual new
  dossier or status change is detected vs. the previous run

### Legal

- Data source: the **Bodemloket** (landelijk register van bodemverontreinigingslocaties), served via a
  public ArcGIS Server REST service (`gis.gdngeoservices.nl`), copyright Rijkswaterstaat. No authentication
  required.
- This is environmental/location data about land parcels, not personal data — no GDPR concerns.
- **Coverage is not uniform across the Netherlands** — the level of detail and dossier availability differs
  per responsible authority. This actor reports what the Bodemloket returns and makes the coverage gap
  explicit (`dekkingBeschikbaar`); it is **not a substitute for a formal soil survey (bodemonderzoek)** or
  legal/technical advice before excavation.
- Geocoding uses the official Dutch government **PDOK Locatieserver** (Kadaster/BZK), a free public service.

### FAQ

**Q: My address returned an empty `wbbLocaties` array — is the soil safe?**
A: It means no registered Wbb soil location overlaps this exact point in the Bodemloket. It does not mean
"no contamination has ever occurred" — always also check `dekkingBeschikbaar` for this region, and consult a
certified soil survey before relying on this for a real excavation decision.

**Q: What does `dekkingBeschikbaar: false` mean?**
A: The responsible authority for this region has not registered an additional web portal/dossier-data flag
in the Bodemloket's own coverage layer. It is informational, not a warning about the Wbb result itself.

**Q: My input was a nonsensical or misspelled address — why did I still get a result?**
A: PDOK's `/free` endpoint does fuzzy/best-effort matching and can return an unrelated (but real) location
even for input that doesn't correspond to any actual address. Check `geocodingBetrouwbaarheid`: a `"laag"`
value is a signal to verify the match manually before relying on it — it does not affect `wbbLocaties` itself,
only how much you should trust that the geocoded location is what you intended.

**Q: Why do some locations show multiple `wbbLocaties` entries?**
A: Wbb soil location polygons can overlap (e.g. an old dossier boundary and a newer one for the same site).
Each is reported separately so nothing is silently merged or dropped.

**Q: Why is `statusver`/`statusOordeel` sometimes `null`?**
A: Not every Wbb dossier has both fields filled in — this is common in the source data itself, not a mapping
error.

### Related Actors

- **[PDOK Adres Geocoding & Buurtdata](https://apify.com/codeclouds/pdok-locatieserver)** — the same official
  PDOK Locatieserver this actor uses internally for geocoding, useful if you need broader address/CBS
  neighbourhood-data lookups beyond soil risk.
- **[NL Faillissementen Monitor](https://apify.com/codeclouds/nl-faillissementen-monitor)** — a complementary
  due-diligence check: bankruptcy/receivership risk on the company side, soil-contamination risk on the
  property side.

***

*Zoekwoorden: bodemloket, bodemverontreiniging check, bodemrisico per adres, Wbb-locatie zoeken,
grondverzet risicocheck, saneringsstatus opzoeken, bodemonderzoek voorscreening, bevoegd gezag bodem.*

### Keywords

bodemloket, soil contamination, bodemverontreiniging, bodemrisico, wbb, grondverzet, sanering, netherlands,
due diligence, excavation risk

### Changelog

#### 0.4.0

- Added `monitorLocaties`: compares each location's Wbb data with the previous run and signals a new dossier
  or a changed `vervolgWbb` status. New charged event `wijziging-signaal` ($0.012), only when a change is
  actually detected. Confirmed by the user (2026-07-16).

#### 0.3.1

- Added a free `RUN_SUMMARY` written to the key-value store at the end of each run (total locations,
  count with a Wbb location, count with errors, count without `dekkingBeschikbaar`, and the
  `geocodingBetrouwbaarheid` distribution). No pricing change.
- Added `afstandMeter` per `wbbLocaties` item when `nabijheidsradiusMeter` is used: haversine distance in
  meters from the input point to the polygon's approximate centroid, with results sorted nearest-first.
  `null` in the default exact-point mode. Enrichment of the already-charged `nabijheidsradius-resultaat`
  event, no pricing change.

#### 0.3.0

- Added `nabijheidsradiusMeter`: search for Wbb locations within a radius around the point instead of only
  exact overlap, using the same Bodemloket layer's `distance`/`units` query parameters. New
  `nabijheidsradiusToegepast` field and charged event `nabijheidsradius-resultaat` ($0.01), confirmed by the
  user (2026-07-14, see docs/actor-verbeteringen/PRIJSBESLISSINGEN.md).

#### 0.2.0

- Added `geocodingScore` (raw PDOK relevance score) and `geocodingBetrouwbaarheid` (hoog/middel/laag,
  calibrated against live PDOK score data) so users can flag geocoding matches worth a manual check. No
  pricing change — enrichment of the existing per-location record.

#### 0.1.0

- Initial release: address/postcode-level Bodemloket (Wbb-locaties) lookup with translated status labels,
  bevoegd gezag, and an explicit regional coverage indicator.

# Actor input Schema

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

Een of meer NL-adressen, postcodes, plaatsnamen, of coordinaten ("lat,lon") om te controleren op bekende bodemverontreinigingslocaties (Wbb) uit het Bodemloket.

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

Hoeveel locaties tegelijk verwerkt worden (geocoding + Bodemloket-lookup per locatie).

## `nabijheidsradiusMeter` (type: `integer`):

Zoekt Wbb-locaties binnen deze straal rond het punt i.p.v. alleen exacte overlap (0 = uit, standaardgedrag). Alleen gecharged (nabijheidsradius-resultaat) als er daadwerkelijk locaties binnen de straal gevonden zijn.

## `monitorLocaties` (type: `boolean`):

Compares each location's Wbb data with the previous run (via the actor's key-value store) and signals a new Wbb dossier or a changed vervolgWbb status. New charged event wijziging-signaal ($0.012), only when a change is actually detected. A standalone one-off call for a location with no prior snapshot returns the normal Wbb result for that location (not empty) but deliberately produces no change signals yet, since there is nothing to compare against — it just establishes the baseline. This setting uses a shared, persistent key-value-store snapshot that scheduled monitoring runs also read/write, so an ad-hoc call in between can shift the baseline a later scheduled run compares against.

## Actor input object example

```json
{
  "locaties": [
    "Bathseweg 27, Rilland"
  ],
  "concurrency": 3,
  "nabijheidsradiusMeter": 0,
  "monitorLocaties": 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": [
        "Bathseweg 27, Rilland"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/nl-bodemrisico-check").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": ["Bathseweg 27, Rilland"] }

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/nl-bodemrisico-check").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": [
    "Bathseweg 27, Rilland"
  ]
}' |
apify call codeclouds/nl-bodemrisico-check --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NL Bodemrisico Check — Bodemloket per Adres",
        "description": "Zoekt bodemverontreinigingslocaties (Wbb) uit het landelijke Bodemloket op voor een NL-adres/postcode/coordinaat, met risicolabels, bevoegd gezag en een expliciete dekkingsindicatie per regio. Voor aannemers en projectontwikkelaars vóór grondverzet.",
        "version": "0.1",
        "x-build-id": "VapVqulb4oZgJpxeG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~nl-bodemrisico-check/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-nl-bodemrisico-check",
                "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-bodemrisico-check/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-nl-bodemrisico-check",
                "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-bodemrisico-check/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-nl-bodemrisico-check",
                "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": "Locaties",
                        "type": "array",
                        "description": "Een of meer NL-adressen, postcodes, plaatsnamen, of coordinaten (\"lat,lon\") om te controleren op bekende bodemverontreinigingslocaties (Wbb) uit het Bodemloket.",
                        "default": [
                            "Bathseweg 27, Rilland"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Gelijktijdige verwerking",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Hoeveel locaties tegelijk verwerkt worden (geocoding + Bodemloket-lookup per locatie).",
                        "default": 3
                    },
                    "nabijheidsradiusMeter": {
                        "title": "Nabijheidsradius (meters)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Zoekt Wbb-locaties binnen deze straal rond het punt i.p.v. alleen exacte overlap (0 = uit, standaardgedrag). Alleen gecharged (nabijheidsradius-resultaat) als er daadwerkelijk locaties binnen de straal gevonden zijn.",
                        "default": 0
                    },
                    "monitorLocaties": {
                        "title": "Monitor locations for changes (across runs)",
                        "type": "boolean",
                        "description": "Compares each location's Wbb data with the previous run (via the actor's key-value store) and signals a new Wbb dossier or a changed vervolgWbb status. New charged event wijziging-signaal ($0.012), only when a change is actually detected. A standalone one-off call for a location with no prior snapshot returns the normal Wbb result for that location (not empty) but deliberately produces no change signals yet, since there is nothing to compare against — it just establishes the baseline. This setting uses a shared, persistent key-value-store snapshot that scheduled monitoring runs also read/write, so an ad-hoc call in between can shift the baseline a later scheduled run compares against.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
