# Dutch Case Law Database — Rechtspraak Court Scraper (`jungle_synthesizer/rechtspraak-nl-dutch-case-law-scraper`) Actor

Every published Dutch court judgment, from rechtbanken through the Hoge Raad and Raad van State, with full text, case metadata and the citation graph between related judgments. Pulled from Rechtspraak's open-data feed, ECLI by ECLI.

- **URL**: https://apify.com/jungle\_synthesizer/rechtspraak-nl-dutch-case-law-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 record scrapeds

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

Learn more: https://docs.apify.com/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

## Dutch Case Law Database — Rechtspraak Scraper

Scrapes published Dutch court judgments from [Rechtspraak](https://www.rechtspraak.nl/), the Dutch judiciary's open-data service. Returns full judgment text, case metadata, court and procedure details, and the citation graph linking a judgment to its appeal or first-instance decision — across every court tier, not just the district courts.

***

### Rechtspraak Scraper Features

- Covers every court tier — rechtbanken, gerechtshoven, the Hoge Raad, Raad van State, Centrale Raad van Beroep and College van Beroep voor het bedrijfsleven, all in one feed
- Returns the full judgment text and the court's own abstract (inhoudsindicatie), not just a title and a link
- Emits the citation graph — related ECLIs linking an appeal to the judgment it appealed and the cassation to both
- Flags `has_full_text` honestly. A share of published ECLIs are metadata-only, and this scraper says so instead of shipping a silent empty field
- Filters by date range, court tier and law area, or skip straight to specific ECLIs you already know
- Pulls statutory citations straight out of the judgment text where the source's own metadata doesn't carry them

***

### Who Uses Dutch Case Law Data?

- **Legal AI teams** — build or fine-tune models on structured Dutch case law instead of scraped HTML
- **Litigation analytics vendors** — track how a legal question moved from rechtbank to Hoge Raad using the citation graph
- **Compliance and research teams** — monitor rulings in a specific rechtsgebied (law area) as they publish
- **Academic researchers** — pull a court's full published history for a study, one ECLI at a time or by date range
- **Legal publishers** — source raw judgment text and metadata for annotation or indexing, rather than re-typing it

***

### How the Rechtspraak Scraper Works

1. Give it a date range (or leave it blank for the last week) and it walks the open-data index day by day, collecting every ECLI published in that window.
2. Each ECLI gets its own lookup against the content endpoint, which returns the full judgment text, the court's abstract, and the citation and legislation metadata attached to it.
3. Already know the ECLIs you want? Pass them directly and the scraper skips the date walk entirely.
4. Every judgment ships as one structured record — no HTML, no re-parsing a deeplink page yourself.

***

### Input

```json
{
  "startDate": "2026-08-01",
  "endDate": "2026-08-05",
  "courtTypes": ["raad van state"],
  "maxItems": 50
}
```

| Field        | Type    | Default     | Description |
|--------------|---------|-------------|-------------|
| `startDate`  | String  | last 6 days | Earliest decision date to include (`YYYY-MM-DD`). |
| `endDate`    | String  | today       | Latest decision date to include (`YYYY-MM-DD`). |
| `courtTypes` | Array   | all tiers   | One or more of `rechtbank`, `gerechtshof`, `hoge raad`, `raad van state`, `crvb`, `cbb`. Leave empty for every tier, including the tuchtrecht (disciplinary) collections. |
| `lawAreas`   | Array   | all areas   | Keep only judgments whose rechtsgebied contains one of these substrings (e.g. `"Strafrecht"`, `"Bestuursrecht"`), case-insensitive. |
| `eclis`      | Array   | —           | Exact ECLI identifiers to fetch directly, skipping the date walk. Overrides `startDate`/`endDate`/`courtTypes`/`lawAreas`. |
| `maxItems`   | Integer | 15          | Maximum number of judgments to return this run. |

#### Direct ECLI lookup

```json
{
  "eclis": ["ECLI:NL:RBAMS:2026:8495", "ECLI:NL:RVS:2026:4585"],
  "maxItems": 2
}
```

***

### Rechtspraak Scraper Output Fields

```json
{
  "ecli": "ECLI:NL:RVS:2026:4585",
  "court": "Raad van State",
  "court_type": "raad van state",
  "court_abbreviation": "RVS",
  "decision_date": "2026-08-05",
  "publication_date": "2026-08-05",
  "case_number": "202502205/1/A2",
  "procedure_type": "Hoger beroep",
  "law_area": ["Bestuursrecht"],
  "summary": "...",
  "full_text": "...",
  "related_ecli": ["ECLI:NL:RBDHA:2025:5874"],
  "cited_legislation": ["artikel 8:69 Awb"],
  "annotations": ["JB 2026/142"],
  "has_full_text": true,
  "source_url": "https://uitspraken.rechtspraak.nl/details?id=ECLI:NL:RVS:2026:4585",
  "scraped_at": "2026-08-27T16:09:52.000Z"
}
```

| Field                | Type    | Description |
|----------------------|---------|-------------|
| `ecli`               | String  | ECLI identifier — the primary key (e.g. `ECLI:NL:RBAMS:2026:8495`). |
| `court`              | String  | Full court name (e.g. Rechtbank Amsterdam, Hoge Raad). |
| `court_type`         | String  | Court tier — `rechtbank`, `gerechtshof`, `hoge raad`, `raad van state`, `CRvB`, `CBb`, or `overig` for tuchtrecht and other bodies outside those six. |
| `court_abbreviation` | String  | Court abbreviation as used in the ECLI (e.g. RBAMS, HR, GHDHA). |
| `decision_date`      | String  | Date the judgment was decided (uitspraakdatum), ISO-8601. |
| `publication_date`   | String  | Date the judgment was published to the open-data feed, ISO-8601. |
| `case_number`        | String  | Zaaknummer, as published — may contain backslashes and spaces. |
| `procedure_type`     | String  | Procedure type(s), joined with `; ` when more than one applies. |
| `law_area`           | Array   | Rechtsgebied — one or more subject-area strings. |
| `summary`            | String  | Inhoudsindicatie — the court's own abstract of the judgment. |
| `full_text`          | String  | Full judgment text. |
| `related_ecli`       | Array   | ECLIs of related judgments — appeal, cassation, or the first-instance decision. Empty when the judgment has no recorded relations. |
| `cited_legislation`  | Array   | Statutory articles cited in the judgment text. Sparse — not every judgment cites legislation by name. |
| `annotations`        | Array   | Vindplaatsen / journal citations (e.g. `NJ 2026/142`). Sparse — most judgments carry none. |
| `has_full_text`      | Boolean | `true` when the content endpoint returned an actual judgment document. A share of published ECLIs are metadata-only, and this field says so rather than leaving `full_text` silently empty. |
| `source_url`         | String  | Public rechtspraak.nl deeplink for this ECLI. |
| `scraped_at`         | String  | Timestamp this record was scraped. |

***

### FAQ

#### How do I scrape Rechtspraak case law?

Rechtspraak Scraper needs no account and no API key. Give it a date range, or a specific list of ECLIs, and it returns structured judgments — full text, metadata, and citations included.

#### How much does the Rechtspraak Scraper cost to run?

Pricing follows the standard pay-per-result profile: a small per-run fee plus a per-record charge. Check the Apify pricing tab on the actor page for current numbers.

#### Can I filter by court or law area?

Yes. Set `courtTypes` to one or more tiers (`rechtbank`, `gerechtshof`, `hoge raad`, `raad van state`, `crvb`, `cbb`), and `lawAreas` to a rechtsgebied keyword like `"Strafrecht"` or `"Bestuursrecht"`. Leave either blank to include everything.

#### Does this scraper cover the Hoge Raad and Raad van State, or only district courts?

Every tier is included by default — rechtbanken through the Hoge Raad and Raad van State, plus the Centrale Raad van Beroep and College van Beroep voor het bedrijfsleven. Use `courtTypes` to narrow it down if you only want one.

#### What if a judgment has no full text available?

Some published ECLIs are metadata-only — the case is published but the document itself isn't attached yet. Those records still come back with `has_full_text: false` so you can tell the difference, instead of a `full_text` field that's silently empty.

***

### Need More Features?

Need custom fields, filters, or a different target site? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use the Rechtspraak Scraper?

- **Every court tier, not just district courts** — the Hoge Raad and Raad van State are the tiers that actually set precedent, and they're included by default
- **The citation graph as a real field** — `related_ecli` links a cassation to the appeal to the first-instance judgment, which turns a pile of documents into a corpus you can actually trace
- **Honest about gaps** — `has_full_text` tells you which records are metadata-only instead of pretending every ECLI has a document

# Actor input Schema

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

What will this data feed? E.g. lead lists, KYB checks, price tracking.

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

Provide any feedback or suggestions for improvements.

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

We'll personally help with your use case. No spam.

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

Earliest decision date to include (YYYY-MM-DD). Walks the open-data index day by day from endDate back to this date. Leave empty to default to 6 days before endDate.

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

Latest decision date to include (YYYY-MM-DD). Leave empty to default to today (UTC).

## `courtTypes` (type: `array`):

Limit results to one or more court tiers. Leave empty to include every tier, including the tuchtrecht (disciplinary) collections that don't map to one of the tiers below.

## `lawAreas` (type: `array`):

Keep only judgments whose rechtsgebied contains one of these substrings (case-insensitive, e.g. "Strafrecht", "Bestuursrecht"). The vocabulary is hierarchical with hundreds of combined values, too many to enumerate as a fixed list — pass any substring the source itself publishes. Leave empty to include every law area.

## `eclis` (type: `array`):

Optional. One or more exact ECLI identifiers (e.g. "ECLI:NL:RBAMS:2026:8495") to fetch directly from the content endpoint, skipping the date-range index walk entirely. startDate/endDate/courtTypes/lawAreas are ignored when this is set.

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

Maximum number of judgments to save this run.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "courtTypes": [],
  "lawAreas": [],
  "eclis": [],
  "maxItems": 15
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "startDate": "",
    "endDate": "",
    "courtTypes": [],
    "lawAreas": [],
    "eclis": [],
    "maxItems": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/rechtspraak-nl-dutch-case-law-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "startDate": "",
    "endDate": "",
    "courtTypes": [],
    "lawAreas": [],
    "eclis": [],
    "maxItems": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/rechtspraak-nl-dutch-case-law-scraper").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "startDate": "",
  "endDate": "",
  "courtTypes": [],
  "lawAreas": [],
  "eclis": [],
  "maxItems": 15
}' |
apify call jungle_synthesizer/rechtspraak-nl-dutch-case-law-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/rechtspraak-nl-dutch-case-law-scraper"
        }
    }
}
```

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/wSJT0StkLPnjR8HVY/builds/gWE6n8yATWXWZ9brQ/openapi.json