# NL Rijksmonument Statuscheck per Adres (`codeclouds/nl-monumentenregister-lookup`) Actor

Check whether a Dutch address, postcode, or coordinate is a Rijksmonument or lies within a protected townscape/UNESCO area, using the official RCE Rijksmonumentenregister (PDOK open data).

- **URL**: https://apify.com/codeclouds/nl-monumentenregister-lookup.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Real estate
- **Stats:** 1 total users, 0 monthly users, 0.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NL Rijksmonument Statuscheck per Adres

Check whether a Dutch address, postcode, or coordinate is a Rijksmonument (state-protected
monument) or lies inside a protected townscape/cityscape (beschermd stads-/dorpsgezicht) or
UNESCO World Heritage area — using the official RCE Rijksmonumentenregister served by PDOK
open data. Each result links straight to the authoritative register record, so you get a
verifiable status, not a guess.

Built as the pre-screening step for renovation/construction due diligence: a Rijksmonument
status can make a separate permit route under the Dutch Omgevingswet relevant, and protected
townscapes can restrict what may change on a facade, garden or street. This Actor answers "what is this
property's heritage status?" before you commit to permit work — it is not a permit-advice tool.

### When should an AI agent use this?

- "Is this address a Rijksmonument, or how far is the nearest one?"
- "Does this renovation address fall inside a protected cityscape or UNESCO World Heritage area?"
- "Check this batch of addresses for Rijksmonument status before we bid on the portfolio."
- "Which monument number is linked to this property, and where is the official register page?"
- "Screen a construction address for heritage status before checking permit implications."
- "How close is this property to the nearest protected monument (distance in meters)?"

### What this Actor does

- Geocodes any Dutch address, postcode, place name, or `"lat,lon"` coordinate via the official PDOK Locatieserver
- Queries the official PDOK/RCE Rijksmonumentenregister WFS (`service.pdok.nl/rce/ps-ch/wfs/v1_0`, PDOK open data) — the same source the Rijksdienst voor het Cultureel Erfgoed publishes, no API key
- Checks **two layers** per location: `rce_inspire_points` (individual Rijksmonumenten as points) and `rce_inspire_polygons` (protected townscapes, landscape views, UNESCO World Heritage areas as polygons)
- Computes the real distance in meters to each monument point / polygon boundary (not a bounding-box guess)
- Flags `isRijksmonument` (Rijksmonument within 25 meters), `isRijksmonumentBinnenZoekstraal` (broader proximity) and `liggingBinnenBeschermdGezicht` explicitly per location
- Returns up to N nearest monuments per location, sorted by distance, with `rceId`, protection class, designation metadata and (where supplied) the official name and `registerUrl`; missing source values are returned as `null`
- Attaches the authoritative `registerUrl` when the source provides one (monumentenregister.cultureelerfgoed.nl or the RCE Gezicht knowledge base)
- Processes up to 50 locations per run with configurable concurrency
- Returns a free `RUN_SUMMARY` with counts, average nearest distance and geocoding reliability
- Includes separate Store dataset views for a location overview and a compact monument summary
- Paginates the official WFS up to 5,000 features per layer, so dense historic centers are not silently truncated
- Exposes the matched address, geocoding type and a warning when PDOK returns a non-address or low-score match
- Includes a fixed disclaimer mirroring the register snapshot (not a legal source in itself)

### Input

| Field | Type | Description | Example |
|---|---|---|---|
| `locaties` | array of strings | Address, postcode, place name, or `"lat,lon"` per location (1-50) | `["Paleis op de Dam, Amsterdam"]` |
| `concurrency` | integer | How many locations to process in parallel (1-10) | `3` |
| `zoekstraalMeter` | integer | Search radius in meters (100-50,000) around the point | `1000` |
| `maxMonumenten` | integer | Max. number of nearest monuments/areas returned per location (1-20) | `3` |
| `includeGezichten` | boolean | Also check protected townscapes/landscape/UNESCO polygons (not just individual monuments) | `true` |

### Output

One dataset item per input location:

```json
{
  "invoer": "Dam 5D, 1012JS Amsterdam",
  "gevonden": true,
  "fout": null,
  "foutcode": null,
  "weergavenaam": "Dam 5D, 1012JS Amsterdam",
  "postcode": "1012JS",
  "gemeente": "Amsterdam",
  "provincie": "Noord-Holland",
  "lat": 52.3731,
  "lon": 4.8931,
  "geocodingScore": 8.9,
  "geocodingBetrouwbaarheid": "middel",
  "geocodingType": "adres",
  "geocodingWaarschuwing": "De matchscore is laag; controleer of de teruggevonden locatie overeenkomt met de invoer.",
  "isRijksmonument": true,
  "isRijksmonumentBinnenZoekstraal": true,
  "rijksmonumentAfstandMeter": 0,
  "liggingBinnenBeschermdGezicht": true,
  "monumenten": [
    {
      "rceId": "10134346.00",
      "soort": "Beschermd stads-/dorpsgezicht",
      "naam": "Amsterdam - Binnen de Singelgracht",
      "registerUrl": "https://kennis.cultureelerfgoed.nl/index.php/Gezicht/1477",
      "beschermingsklasse": "http://inspire.ec.europa.eu/codelist/ProtectionClassificationValue/cultural",
      "afstandMeter": 0,
      "ligtBinnen": true
    },
    {
      "rceId": "11302.00",
      "soort": "Rijksmonument",
      "naam": null,
      "registerUrl": "https://monumentenregister.cultureelerfgoed.nl/monumenten/3014",
      "beschermingsklasse": "http://inspire.ec.europa.eu/codelist/ProtectionClassificationValue/cultural",
      "legaleGrondslagDatum": "1972-02-29",
      "percentageOnderDesignatie": "100",
      "afstandMeter": 172,
      "ligtBinnen": false
    }
  ],
  "zoekstraalMeter": 1000,
  "aantalGevonden": 2,
  "aantalTeruggegeven": 2,
  "resultaatAfgekapt": false,
  "bron": "PDOK Rijksmonumentenregister WFS (service.pdok.nl/rce/ps-ch/wfs/v1_0) + PDOK Locatieserver (geocoding)",
  "disclaimer": "Deze actor is een spiegel van het officiële RCE Rijksmonumentenregister op de peildatum van de dataset. Het levert geen juridisch bindend advies — raadpleeg voor de authentieke versie monumentenregister.cultureelerfgoed.nl of de gemeentelijke vergunningverlener."
}
```

`fout` is a human-readable error message (`null` on success). `foutcode` is a machine-readable
classification for agents/automation, one of:

- `GEEN_GEOCODING_MATCH` — the address/postcode could not be resolved to a location (not retryable)
- `UPSTREAM_ERROR` — a temporary HTTP/network failure at PDOK (retryable)
- `ONBEKENDE_FOUT` — any other unexpected error

`isRijksmonument` is true only when the nearest Rijksmonument point is within 25 meters of the
matched location. `isRijksmonumentBinnenZoekstraal` is the broader proximity signal, and
`rijksmonumentAfstandMeter` always shows the nearest measured distance. Because geocoding is
approximate, verify the matched address before using the result for formal decisions.

`geocodingType` and `geocodingWaarschuwing` make address matching transparent: when PDOK returns a
street, postcode or place instead of an address — or returns a low-score match — the warning asks
you to verify the location manually. `legaleGrondslagDatum` and `percentageOnderDesignatie` come
straight from the RCE record when available; the first field is not automatically the formal
designation date.

`soort` classifies the record by its RCE namespace: `Rijksmonument`, `Beschermd stads-/dorpsgezicht`,
`UNESCO-werelderfgoedgebied`, `Landschapsbeeld`, or the raw namespace value when the feed
changes (defensive — never a guessed label).

### Use cases

- **Renovation/construction due diligence** — check whether a target property is a Rijksmonument or sits inside a protected townscape before engaging an architect or applying for a permit.
- **Real-estate valuations and listings** — heritage status is a material fact for buyers, insurers and lenders; enrich your address data with a verifiable monument flag and register link.
- **Architect/contractor pre-screening** — heritage status can be relevant to a separate Omgevingsvergunning route; knowing this early saves permit-application surprises.
- **Portfolio screening** — run up to 50 addresses per call and flag every location that touches protected heritage.
- **AI-agent and MCP workflows** — plug the structured output into a due-diligence pipeline or a permit-readiness assistant.

### Pricing

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

| Event | Price | When it fires |
|---|---|---|
| `apify-actor-start` | $0.00005 | Apify default, per run start |
| `locatie-resultaat` | **$0.006** | Per address/postcode/coordinate that resolves and is successfully checked against the register |
| `rijksmonument-treffer-signaal` | **$0.015** | In addition, per location where the nearest Rijksmonument is within 25 meters — a direct, actionable signal |

Lookups that fail (geocoding miss or upstream error) are never charged.

### Legal

- **Source:** the official RCE Rijksmonumentenregister published as an open WFS by PDOK
  (`service.pdok.nl/rce/ps-ch/wfs/v1_0`). Government open data, explicitly intended for reuse
  (INSTRUCTIE sectie 3: low risk). No API key or login; consult the source terms for attribution
  and reuse conditions.
- **No personal data:** monument status is a property of a building/parcel, not of a natural
  person. The register does not contain owner names.
- **No advice language:** this Actor returns a factual register status plus a link to the
  authoritative source — it does not give permit or renovation advice.
- **Disclaimer:** output mirrors the register at the dataset snapshot date. For the legally
  binding version, always consult `monumentenregister.cultureelerfgoed.nl` or the municipality.
- The end user remains responsible for their own GDPR/compliance when further processing the data.

### FAQ

**Q: Does a monument flag mean I cannot renovate?**
A: No. A Rijksmonument status can make a separate permit route under the Omgevingswet relevant
and may restrict changes; the output is a factual status, not permit advice. Check with the
municipality or a heritage consultant.

**Q: How accurate is the address matching?**
A: Geocoding uses the official PDOK Locatieserver. The `geocodingBetrouwbaarheid` field mirrors
PDOK's match quality; treat a `laag` value as "verify manually".

**Q: Why is the monument name sometimes empty?**
A: The WFS only carries a `text` name for protected scapes (e.g. "Amsterdam - Binnen de
Singelgracht"); individual monument points often have an empty `text`. The `registerUrl` always
points to the authoritative record with the full name and description.

**Q: Does this cover protected townscapes?**
A: Yes — set `includeGezichten: true` (default) to also check `rce_inspire_polygons`, which
covers beschermde stads-/dorpsgezichten, landschapsbeelden and UNESCO World Heritage areas.

### Related Actors

- **[NL Natura2000 Afstandscheck](https://apify.com/codeclouds/nl-natura2000-afstandscheck)** — same pre-screening pattern for nature-protection risk (stikstof/Natura2000) before a permit application.
- **[NL AHN Hoogtedata Lookup](https://apify.com/codeclouds/nl-ahn-hoogtedata-lookup)** — add ground/surface height per address for the same due-diligence dossier.
- **[NL Kadastrale Perceelgrenzen Lookup](https://apify.com/codeclouds/nl-kadastrale-perceelgrenzen-lookup)** — parcel boundary and surface data for the same property.
- **[Vastgoed XXL](https://apify.com/codeclouds/vastgoed-xxl)** — broader per-address enrichment (CBS neighbourhood figures, flood risk, foundation attention areas).

***

*Zoekwoorden: rijksmonument, monumentenregister, monumentnummer, beschermd stadsgezicht, beschermd dorpsgezicht, cultuurhistorische waarde, RCE, cultureel erfgoed, omgevingsvergunning, Rijksdienst voor het Cultureel Erfgoed, monumentenvergunning, vergunningplicht, UNESCO werelderfgoed.*

### Keywords

rijksmonument, monumentenregister, heritage, protected monument, netherlands, dutch heritage, rce, pdok, open-data, cultural-heritage, townscape, world-heritage, omgevingsvergunning, due-diligence, real-estate, lookup, geocoding

### Changelog

#### 0.2.0

- Fix: the required `locaties` field now ships with a `default` and `prefill` example value (Dam, Amsterdam + a coordinate). Without it, an empty input failed validation immediately, which made the Apify automatic test fail and flagged the actor as under maintenance. The Start button in the Console now also works without typing anything first.
- `concurrency`, `zoekstraalMeter` and `maxMonumenten` are now typed as whole numbers with the same limits the Actor enforces internally, so invalid values are caught in the input form instead of failing the run.

#### 0.1.0

- Initial release: PDOK/RCE WFS lookup (points + protected-scape polygons), PDOK geocoding, distance-in-meters calculation, WFS pagination, address-preference and place/postcode context in geocoding, transparency warnings, RCE designation metadata, free run summary, PPE pricing, and demo input.

# Actor input Schema

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

Een of meer zoektermen (1-50): een volledig NL-adres, een postcode (bv. "1011 JS"), of WGS84-coördinaat binnen Nederland (bv. "52.37,4.90"). Elke locatie wordt één voor één gecodeerd via PDOK Locatieserver en vergeleken met het Rijksmonumentenregister.

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

Geheel getal 1-10: hoeveel locaties gelijktijdig verwerkt worden (geocoding + monumentenlookup).

## `zoekstraalMeter` (type: `integer`):

Geheel getal 100-50.000: straal waarin gezocht wordt naar Rijksmonumenten en beschermde gebieden. De actor vergroot de straal niet automatisch.

## `maxMonumenten` (type: `integer`):

Geheel getal 1-20: maximum aantal monumenten/gebieden dat per locatie wordt teruggegeven, oplopend gesorteerd op afstand.

## `includeGezichten` (type: `boolean`):

Als aan: ook stads-/dorpsgezichten, landschapsbeeld- en UNESCO-werelderfgoedgebieden (polygons) worden gecontroleerd, naast individuele Rijksmonumenten (points).

## Actor input object example

```json
{
  "locaties": [
    "Dam 5D, 1012JS Amsterdam",
    "52.3702,4.8952"
  ],
  "concurrency": 3,
  "zoekstraalMeter": 1000,
  "maxMonumenten": 3,
  "includeGezichten": true
}
```

# Actor output Schema

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

Alle resultaten zijn opgeslagen in de dataset.

# 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": [
        "Dam 5D, 1012JS Amsterdam",
        "52.3702,4.8952"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/nl-monumentenregister-lookup").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": [
        "Dam 5D, 1012JS Amsterdam",
        "52.3702,4.8952",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/nl-monumentenregister-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "Dam 5D, 1012JS Amsterdam",
    "52.3702,4.8952"
  ]
}' |
apify call codeclouds/nl-monumentenregister-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codeclouds/nl-monumentenregister-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oIClXQeWuKTKQdU7O/builds/7anJdmhg9wO1bUkRY/openapi.json