# NL Jurisprudentie Monitor per Rechtsgebied (`codeclouds/nl-jurisprudentie-monitor`) Actor

Monitor nieuwe rechtspraak-uitspraken per rechtsgebied, met wijzigingsdetectie en Hoge Raad-landmark-signalen.

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

## Pricing

from $3.00 / 1,000 uitspraak-results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 Jurisprudentie Monitor per Rechtsgebied 🇳🇱

Monitor **Dutch court rulings (jurisprudentie)** by legal area and court instance — with automatic change detection and landmark signals for Hoge Raad (Supreme Court), Raad van State and Centrale Raad van Beroep decisions.

data.rechtspraak.nl publishes thousands of rulings every month across dozens of legal areas and court levels. Finding the ones relevant to your practice or research currently means searching through a flat, unfiltered list. This actor turns that open data feed into a structured, incremental stream grouped by rechtsgebied and instantie, so you can monitor new decisions in the areas that matter to you.

### Who is this for?

- **Law firms & legal departments** tracking new rulings in specific practice areas (e.g. arbeidsrecht, bestuursrecht)
- **Legal tech & AI platforms** needing clean, structured ruling data for RAG or knowledge-base updates
- **Compliance teams** monitoring regulatory shifts in specific jurisdictions or court levels
- **Researchers & journalists** tracking Hoge Raad (Supreme Court) landmark decisions
- **Government & policy analysts** following developments in administrative or tax law
- **AI agents** — flat JSON output, MCP-ready, ideal for agentic legal research workflows

### When should an AI agent use this?

- "Show me new arbeidsrecht rulings from the Rechtbank since yesterday."
- "Which Hoge Raad (Supreme Court) decisions were published this week in civiel recht?"
- "Has there been a new bestuursrecht ruling on vreemdelingenrecht from the Gerechtshof?"
- "List all new rulings in my subscribed legal areas since the last run."
- "Give me the latest Hoge Raad landmark decisions with full metadata."
- "Monitor for new tax law (belastingrecht) rulings and alert me when they appear."

### What this Actor does

- **Incremental monitoring** — only returns rulings modified since the previous run, so you get new and changed decisions without duplicates
- **Legal area filtering** — client-side filtering by rechtsgebied (the official API does not support server-side area filtering)
- **Court instance filtering** — filter by Hoge Raad, Gerechtshof, or Rechtbank
- **Landmark signal** — rulings from Hoge Raad (Supreme Court), Raad van State (highest administrative court) and Centrale Raad van Beroep (highest court for social security/civil service law) are flagged `isLandmark: true` because these highest-instance colleges carry binding weight as precedent within their legal domain
- **Two-step fetch architecture** — first fetches a search result list (ECLI identifiers), then enriches each ruling with content (legal area, court, summary, links)
- **Flat, structured output** — one JSON object per ruling, grouped by legal area and court, ready for datasets, webhooks, or MCP tools

### Input options

| Field | Description | Example |
|---|---|---|
| `rechtsgebieden` | Filter by legal area. Leave empty to include all. | `["Civiel recht", "Bestuursrecht"]` |
| `instantieTypes` | Filter by court instance level | `["Hoge Raad", "Gerechtshof", "Rechtbank"]` |
| `maxResults` | Maximum number of rulings to return (1-500) | `100` |
| `alleenNieuweSindsVorigeRun` | Only return rulings modified since the previous run | `true` |
| `trackVolumeTrend` | Compare the number of rulings per legal area against the previous run | `false` |
| `haalVolledigeTekstOp` | Extract the full ruling text (no extra API call — already in the fetched content response) | `false` |

### Output

Each result is one court ruling, enriched with metadata from the content endpoint:

```json
{
  "ecli": "ECLI:NL:HR:2023:1234",
  "titel": "ECLI:NL:HR:2023:1234, Hoge Raad, 15-03-2023, Uitspraak over arbeidsrecht",
  "instantie": "Hoge Raad",
  "datum": "2023-03-15",
  "rechtsgebied": "Civielrecht",
  "rechtsgebiedUri": "http://psi.rechtspraak.nl/rechtsgebied#civielRecht",
  "samenvatting": "Samenvatting van de uitspraak...",
  "urlHtml": "https://zoek.rechtspraak.nl/uitspraken?id=ECLI:NL:HR:2023:1234",
  "urlContentXml": "https://data.rechtspraak.nl/uitspraken/content?id=ECLI:NL:HR:2023:1234",
  "isNieuweUitspraakSindsVorigeRun": true,
  "isLandmark": true,
  "volledigeTekst": null
}
````

- **`rechtsgebied`** is normalized from the official PSI taxonomy (free-text in the source is mapped to a canonical label)
- **`isLandmark`** is `true` for Hoge Raad (Supreme Court), Raad van State and Centrale Raad van Beroep rulings — these highest-instance colleges carry the most weight as binding precedent within their legal domain
- **`isNieuweUitspraakSindsVorigeRun`** is `true` when `alleenNieuweSindsVorigeRun` is enabled and the ruling was modified since the previous run
- **`volledigeTekst`** is `null` unless `haalVolledigeTekstOp` is enabled and text was actually found

#### Full ruling text (`haalVolledigeTekstOp`, optional, separately charged)

With `haalVolledigeTekstOp: true`, `volledigeTekst` is filled with the full text of the ruling, extracted from
the same content response already fetched for the metadata — **no third API call**, since the response that
provides `instantie`/`rechtsgebied`/`samenvatting` already contains the full `<uitspraak>` (or `<conclusie>` for
advocate-general opinions) body. Charged as `volledige-tekst-record`, only when text is actually extracted (a
ruling type without that element, or a parse miss, gets `volledigeTekst: null` and no charge).

#### Volume trend per legal area (`trackVolumeTrend`, optional, separately charged)

With `trackVolumeTrend: true`, the actor counts how many rulings were delivered per `rechtsgebied` this run and
compares that against the previous run's count (stored in its key-value store). One extra dataset record per
legal area seen this run or last run:

```json
{
  "type": "volumetrend-signaal",
  "rechtsgebied": "Strafrecht",
  "huidigAantal": 12,
  "vorigAantal": 10,
  "percentageVerandering": 20,
  "periodeVanaf": "2026-07-09",
  "periodeTot": "2026-07-16"
}
```

`percentageVerandering` is `null` when the legal area wasn't seen in the previous run (no known baseline) or
the previous count was `0` (division by zero gives no meaningful percentage). Charged as `volumetrend-signaal`,
only for legal areas where a percentage was actually computable.

### Use cases

**Daily monitoring for a legal practice, Hoge Raad landmarks only:**

```json
{
  "rechtsgebieden": ["Civiel recht", "Bestuursrecht"],
  "instantieTypes": ["Hoge Raad"],
  "maxResults": 50,
  "alleenNieuweSindsVorigeRun": true
}
```

**Full scan of arbeidsrecht rulings across all courts, last 90 days:**

```json
{
  "rechtsgebieden": ["Arbeidsrecht"],
  "instantieTypes": ["Hoge Raad", "Gerechtshof", "Rechtbank"],
  "maxResults": 200,
  "alleenNieuweSindsVorigeRun": false
}
```

**Track tax law changes from the Gerechtshof only:**

```json
{
  "rechtsgebieden": ["Belastingrecht"],
  "instantieTypes": ["Gerechtshof"],
  "maxResults": 100,
  "alleenNieuweSindsVorigeRun": true
}
```

### Scheduling & integrations

- **Schedules** — run daily or weekly and get only new/changed rulings since the last run
- **Integrations** — push results to Google Sheets, Slack, Zapier, Make, or any webhook
- **API** — fetch the dataset as JSON, CSV or Excel from your own code
- **MCP** — expose this actor as a tool for AI agents (Claude, Cursor, and other MCP clients)

### Data source & legality

This actor uses the **official open data API** of the Dutch judiciary (data.rechtspraak.nl), the same source behind zoek.rechtspraak.nl.

- ✅ No scraping — official Atom feed and structured XML content endpoint, no login required
- ✅ Court rulings are public documents intended for open access; no personal data involved
- ⚠️ This actor is a monitoring/search tool, not legal advice. Always consult the official ruling (`urlHtml`) for legally binding interpretation.

### Pricing

Pay-per-event: you only pay for rulings actually delivered, plus a small extra charge for each ruling flagged as new since the last run (incremental mode).

| Event | Price | Description |
|---|---|---|
| `apify-actor-start` | $0.00005 | Apify default |
| `uitspraak-result` | $0.003 | Each ruling delivered to your dataset |
| `rechtsgebied-alert` | $0.008 | Each new ruling in incremental mode (premium signal for change detection) |
| `volledige-tekst-record` | $0.015 | Per ruling, only with `haalVolledigeTekstOp` enabled and text actually extracted |
| `volumetrend-signaal` | $0.01 | Per legal area, only with `trackVolumeTrend` enabled and a previous count actually known |

### FAQ

**Why two API calls per ruling?**
The official API's search endpoint does not support filtering by legal area (rechtsgebied). The actor first fetches a list of ECLIs matching your date filter, then enriches each one individually to extract the legal area and court instance.

**What's the rate limit?**
The source allows roughly 10 requests per second. The actor enforces a 100ms delay between content fetches to stay within limits.

**Why does `maxResults` max out at 500?**
Each result requires an extra content fetch. Higher limits would make runs very slow and risk hitting rate limits. Use scheduled incremental runs for ongoing monitoring instead.

**Is `isLandmark` only for Hoge Raad?**
No — `isLandmark` is `true` for Hoge Raad (Supreme Court), Raad van State (highest administrative court) and Centrale Raad van Beroep (highest court for social security and civil service law) rulings. These are the highest-instance colleges with binding precedent value within their respective legal domains. Gerechtshof and Rechtbank rulings are important but not formally "landmark" in the same sense.

**How does incremental mode work?**
On the first run (no stored baseline yet), the actor looks back 30 days via `modified=<30 days ago>` so it doesn't come back empty. On subsequent runs, it uses `modified=<lastRunDate>` to fetch only rulings changed since then, and stores today's date as the new baseline. Each ruling is flagged `isNieuweUitspraakSindsVorigeRun: true`.

**What happens when `alleenNieuweSindsVorigeRun` is disabled?**
The actor still bounds the scan to the last 90 days via `modified` — it does not crawl the entire rechtspraak.nl archive from its oldest entry onward. Rulings are not flagged `isNieuweUitspraakSindsVorigeRun` in this mode.

### Related Actors

Also by this developer — Dutch/EU public-data actors that pair well with this one:

- **[NL CAO Wijzigingen Database](https://apify.com/codeclouds/nl-cao-wijzigingen-database)** — same official-publication → structured-feed pattern, applied to Dutch collective labour agreement changes.
- **[NL & EU Government Tenders Scraper](https://apify.com/codeclouds/nl-eu-tenders-scraper)** — structured feed from government procurement tenders, useful for legal teams tracking public contract opportunities.
- **[NL Emissiezones Monitor](https://apify.com/codeclouds/nl-emissiezones-monitor)** — Dutch environmental zone monitoring with change detection, same incremental alerting pattern.

***

*Zoekwoorden: rechtspraak monitor, jurisprudentie per rechtsgebied, Hoge Raad uitspraken, Nederlandse rechtspraak, rechtsgebied alerts, uitspraken feed, rechtbank monitoring, civiel recht, bestuursrecht, strafrecht, arbeidsrecht, belastingrecht, vreemdelingenrecht, legal tech NL, open data rechtspraak.*

### Keywords

rechtspraak, jurisprudentie, uitspraken, Hoge Raad, gerechtshof, rechtbank, rechtsgebied, legal monitoring, netherlands, open data, precedent, legal tech, ECLI, rechtspraak.nl, civiel recht, bestuursrecht, strafrecht, arbeidsrecht, belastingrecht, vreemdelingenrecht

### Changelog

#### 0.2.0 - Full text extraction & volume trend

- Added `haalVolledigeTekstOp` — extracts the full ruling text (`volledigeTekst`) from the same content
  response already fetched for the metadata, no extra API call. New `volledige-tekst-record` event ($0.015),
  only charged when text is actually found.
- Added `trackVolumeTrend` — compares the number of rulings delivered per legal area against the previous run
  via the key-value store. New `volumetrend-signaal` event ($0.01), only charged when a previous count is
  actually known for that legal area.

#### 0.1.2 - Enhancement

- Landmark signal extended: `isLandmark` now also flags Raad van State and Centrale Raad van Beroep rulings, next to Hoge Raad, since these are also highest-instance colleges with precedent value in their legal domain
- Legal area normalization extended: `normaliseerRechtsgebied()` now also recognizes Personen- en familierecht, Arbeidsrecht, Insolventierecht, Verbintenissenrecht, Ambtenarenrecht, Europees recht and Internationaal publiekrecht, reducing the number of rulings that fall through to unmapped free text

#### 0.1.1 - Bugfix

- Fixed incremental mode never seeing the previous run's `lastRunDate`: the actor was reading/writing to
  Apify's per-Run *default* key-value store, which is not shared between separate runs. Now uses a named,
  persistent key-value store.

#### 0.1.0 - Initial release

- Incremental ruling monitor with two-step fetch architecture (search + content enrichment)
- Filtering by legal area (client-side) and court instance (Hoge Raad / Gerechtshof / Rechtbank)
- Landmark signal for Hoge Raad rulings (`isLandmark: true`)
- Key-value store for incremental mode (`alleenNieuweSindsVorigeRun`)
- PPE pricing: `uitspraak-result` @ $0.003, `rechtsgebied-alert` @ $0.008

# Actor input Schema

## `rechtsgebieden` (type: `array`):

Filter by legal area. Only rulings from selected areas are returned. Leave empty to include all areas.

## `instantieTypes` (type: `array`):

Filter by court instance level.

## `maxResults` (type: `integer`):

Maximum number of rulings to return (1-500). Each result requires an extra content fetch, so keep this reasonable.

## `alleenNieuweSindsVorigeRun` (type: `boolean`):

When enabled, only return rulings modified since the previous run, and trigger alerts for new rulings in selected areas. Ideal for scheduled monitoring. Default is true, so this behavior is already active on an ad-hoc call unless explicitly disabled. On the very first call (no stored baseline yet), it falls back to a 30-day lookback window rather than returning nothing. Uses a shared, persistent key-value store baseline that is also updated by scheduled monitoring runs — an ad-hoc call in between can shift that baseline forward.

## `trackVolumeTrend` (type: `boolean`):

Compares the number of rulings delivered per legal area against the previous run (via the actor's key-value store). New charged event volumetrend-signaal ($0.01), only when a previous count is actually known for that legal area.

## `haalVolledigeTekstOp` (type: `boolean`):

Extracts the full ruling text from the same content response already fetched for the metadata (no extra API call). New charged event volledige-tekst-record ($0.015), only when text is actually found.

## Actor input object example

```json
{
  "rechtsgebieden": [],
  "instantieTypes": [
    "Hoge Raad",
    "Gerechtshof",
    "Rechtbank"
  ],
  "maxResults": 100,
  "alleenNieuweSindsVorigeRun": true,
  "trackVolumeTrend": false,
  "haalVolledigeTekstOp": 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/nl-jurisprudentie-monitor").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call codeclouds/nl-jurisprudentie-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NL Jurisprudentie Monitor per Rechtsgebied",
        "description": "Monitor nieuwe rechtspraak-uitspraken per rechtsgebied, met wijzigingsdetectie en Hoge Raad-landmark-signalen.",
        "version": "0.1",
        "x-build-id": "NaSAcp3ryejoQeYkf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~nl-jurisprudentie-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-nl-jurisprudentie-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/codeclouds~nl-jurisprudentie-monitor/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-nl-jurisprudentie-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/codeclouds~nl-jurisprudentie-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-nl-jurisprudentie-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "rechtsgebieden": {
                        "title": "Rechtsgebieden",
                        "type": "array",
                        "description": "Filter by legal area. Only rulings from selected areas are returned. Leave empty to include all areas.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Civiel recht",
                                "Strafrecht",
                                "Bestuursrecht",
                                "Belastingrecht",
                                "Vakantietoelichten- en toezichtsrecht",
                                "Vreemdelingenrecht",
                                "Omgevingsrecht",
                                "Socialezekerheidsrecht",
                                "Handelsrecht",
                                "Intellectueel eigendomsrecht",
                                "Personen- en familierecht",
                                "Arbeidsrecht",
                                "Insolventierecht",
                                "Verbintenissenrecht",
                                "Ambtenarenrecht",
                                "Europees recht",
                                "Internationaal publiekrecht"
                            ],
                            "enumTitles": [
                                "Civiel recht",
                                "Strafrecht",
                                "Bestuursrecht",
                                "Belastingrecht",
                                "Vakantietoelichten- en toezichtsrecht",
                                "Vreemdelingenrecht",
                                "Omgevingsrecht",
                                "Socialezekerheidsrecht",
                                "Handelsrecht",
                                "Intellectueel eigendomsrecht",
                                "Personen- en familierecht",
                                "Arbeidsrecht",
                                "Insolventierecht",
                                "Verbintenissenrecht",
                                "Ambtenarenrecht",
                                "Europees recht",
                                "Internationaal publiekrecht"
                            ]
                        },
                        "default": []
                    },
                    "instantieTypes": {
                        "title": "Instantie Types",
                        "type": "array",
                        "description": "Filter by court instance level.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Hoge Raad",
                                "Gerechtshof",
                                "Rechtbank"
                            ],
                            "enumTitles": [
                                "Hoge Raad",
                                "Gerechtshof",
                                "Rechtbank"
                            ]
                        },
                        "default": [
                            "Hoge Raad",
                            "Gerechtshof",
                            "Rechtbank"
                        ]
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of rulings to return (1-500). Each result requires an extra content fetch, so keep this reasonable.",
                        "default": 100
                    },
                    "alleenNieuweSindsVorigeRun": {
                        "title": "Only New Since Last Run",
                        "type": "boolean",
                        "description": "When enabled, only return rulings modified since the previous run, and trigger alerts for new rulings in selected areas. Ideal for scheduled monitoring. Default is true, so this behavior is already active on an ad-hoc call unless explicitly disabled. On the very first call (no stored baseline yet), it falls back to a 30-day lookback window rather than returning nothing. Uses a shared, persistent key-value store baseline that is also updated by scheduled monitoring runs — an ad-hoc call in between can shift that baseline forward.",
                        "default": true
                    },
                    "trackVolumeTrend": {
                        "title": "Track ruling volume trend per legal area",
                        "type": "boolean",
                        "description": "Compares the number of rulings delivered per legal area against the previous run (via the actor's key-value store). New charged event volumetrend-signaal ($0.01), only when a previous count is actually known for that legal area.",
                        "default": false
                    },
                    "haalVolledigeTekstOp": {
                        "title": "Fetch full ruling text",
                        "type": "boolean",
                        "description": "Extracts the full ruling text from the same content response already fetched for the metadata (no extra API call). New charged event volledige-tekst-record ($0.015), only when text is actually found.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
