# German Case Law Search & Ruling Alerts (BGH, BVerfG, BAG) (`orange_briefcase_hrj/german-case-law-search`) Actor

$1 per 1,000 decisions. Search German federal court decisions (Rechtsprechung, Urteile) of BGH, BVerfG, BVerwG, BFH, BAG, BSG and BPatG by keyword, court, date, ECLI or file number via the official NeuRIS API. Optional full text and alerts for new rulings.

- **URL**: https://apify.com/orange_briefcase_hrj/german-case-law-search.md
- **Developed by:** [Fast Agent](https://apify.com/orange_briefcase_hrj) (community)
- **Categories:** Business, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 court decisions

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

**Price: $1 per 1,000 court decisions** ($0.90 on Apify Scale, $0.80 on Business and above) + $0.00005 per run · full text at no extra cost · official NeuRIS API, no key or proxy

### Auf Deutsch

**Rechtsprechung der Bundesgerichte durchsuchen und neue Urteile abonnieren.** Dieser Actor liefert Entscheidungen von BGH, BVerfG, BVerwG, BFH, BAG, BSG und BPatG aus dem amtlichen Portal *Rechtsinformationen des Bundes* (NeuRIS, Bundesministerium der Justiz) als JSON, CSV oder Excel. Gerichtsentscheidungen und amtliche Leitsätze sind nach § 5 UrhG gemeinfrei; jeder Datensatz nennt Quelle und Abrufdatum.

**So suchen Sie:**

- **Stichwortsuche:** Suchbegriffe auf Deutsch eingeben (alle Wörter müssen vorkommen), optional nach Gericht, Entscheidungsart und Datum filtern, z. B. `"keywords": "Mietminderung", "courts": ["BGH"]`.
- **Gezielter Abruf:** Modus *Lookup* wählen und ECLIs oder Aktenzeichen einfügen (z. B. `VIII ZR 198/15`).
- **Urteils-Alert:** *Only new decisions since last run* einschalten und täglich oder wöchentlich planen – Sie erhalten nur neue Entscheidungen.

**Wichtige Ausgabefelder:** `court` (Gericht), `chamber` (Senat/Spruchkörper), `decisionDate` (Entscheidungsdatum), `documentType` (Urteil, Beschluss …), `fileNumbers` (Aktenzeichen), `ecli`, `subject` (Titelzeile), `fullText` (Leitsatz, Tenor, Tatbestand, Gründe – optional), `normReferences` (zitierte Normen), `url` (Link zur Quelle).

**Preis:** 1 $ pro 1.000 Entscheidungen plus 0,00005 $ pro Lauf; der Volltext kostet nichts extra.
**Mit KI-Assistenten:** Funktioniert auch in ChatGPT, Claude und Cursor über den Apify-MCP-Server – siehe *Use it from ChatGPT, Claude or Cursor* unten.

Search **German federal court decisions** – Bundesgerichtshof (BGH), Bundesverfassungsgericht (BVerfG), Bundesverwaltungsgericht (BVerwG), Bundesfinanzhof (BFH), Bundesarbeitsgericht (BAG), Bundessozialgericht (BSG) and Bundespatentgericht (BPatG) – and get **alerts for new rulings**. Data comes straight from the official federal legal information portal **Rechtsinformationen des Bundes (NeuRIS)**, run by the German Federal Ministry of Justice. You don't need an API key, a proxy or a browser.

Search by keyword (*Rechtsprechung durchsuchen*), court, decision type and date range. You can also look up a decision by **ECLI** or **Aktenzeichen** (file number). Results come back as clean JSON, CSV or Excel, with optional **full text**: headnote (*Leitsatz*), operative part (*Tenor*), facts (*Tatbestand*), reasons (*Entscheidungsgründe*), cited statutes (*Normenkette*) and lower-court decisions.

> Germany is the first jurisdiction. The input and output formats are country-neutral, and **France (Judilibre)** and the **Netherlands (Rechtspraak)** are planned.

### What can you use it for?

- **Legal research and know-how**: find all BGH or BAG decisions on a topic, e.g. *"Datenschutz Schadensersatz"* or *"Mietminderung Schimmel"*.
- **Practice-area monitoring**: schedule a daily or weekly run in alert mode and get only rulings you haven't seen before, e.g. new BFH tax decisions or new BAG labour-law rulings.
- **Citation checking**: turn a list of ECLIs or file numbers into titles, dates, courts and links.
- **Legal tech, RAG and AI pipelines**: feed full-text decisions with stable identifiers (ECLI, document number) into search indexes or LLM retrieval.
- **Compliance and newsletters**: track case law on GDPR/DSGVO, employment, competition or tax, and send results to Slack, email, Google Sheets or Make/Zapier via Apify integrations.

### Use it from ChatGPT, Claude or Cursor

Give your AI assistant real German federal court decisions to cite (BGH, BVerfG, BAG, BFH and more) from the official NeuRIS portal, with file numbers and ECLIs, instead of guessing.

This Actor works as a tool in any AI assistant that supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io), through the official [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). You ask in plain language; the assistant fills in the filters, runs the Actor and answers from the results.

**MCP server URL (this Actor only):**

```text
https://mcp.apify.com?tools=orange_briefcase_hrj/german-case-law-search
```

**Set it up once (you need a free Apify account):**

- **Claude (claude.ai and Claude Desktop):** open **Settings → Connectors → Add → Add custom connector**. Enter a name (for example `German case law`), paste the URL above as the **Remote MCP server URL**, select **Continue**, keep the detected settings and select **Add**. Sign in to Apify when your browser opens. On Team and Enterprise plans, an Owner adds the connector for the organisation.
- **ChatGPT:** custom connectors need ChatGPT **Developer mode** (beta). Go to **Settings → Apps & Connectors → Create**, paste the URL above as the **MCP Server URL**, choose **OAuth** authentication and select **Create**, then sign in to Apify. In a new chat, select **+ → More** and pick the connector.
- **Cursor:** add this to `~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project). Cursor opens your browser to sign in to Apify:

```json
{
  "mcpServers": {
    "german-case-law-search": {
      "url": "https://mcp.apify.com?tools=orange_briefcase_hrj/german-case-law-search"
    }
  }
}
```

- **VS Code, Windsurf and other MCP clients:** add the same URL as a remote (Streamable HTTP) MCP server. If a client can't do OAuth, send the header `Authorization: Bearer <YOUR_APIFY_TOKEN>` instead (token from **Apify Console → Settings → API & Integrations**).

Already connected to the full Apify server (`https://mcp.apify.com`) or the Apify plugin for Cursor, Claude Code or VS Code? Just mention `orange_briefcase_hrj/german-case-law-search` in your request.

**Try asking:**

> "Find the 10 most recent BAG decisions on Kündigung and summarise the headnotes in English, with file numbers and ECLIs."
>
> "Get BGH VIII ZR 198/15 with full text and explain the court's reasoning in plain English."
>
> "Find BGH rulings on Mietminderung decided since 1 January 2024 and group them by outcome."

**Cost:** a run started by your assistant is a normal run of this Actor, billed to your Apify account at the usual pay-per-event price ($1 per 1,000 decisions, see the pricing section below). This Actor charges nothing extra for runs that come through an assistant. Asking for a small number of results (for example "the top 20") keeps runs cheap, and the Apify Free plan's monthly credit covers plenty of tests.

### Screenshots

Real output from the saved example tasks (test runs on 26 October 2026):

![New Federal Labour Court (BAG) rulings: date, court, chamber, decision type, file number, subject and ECLI](https://api.apify.com/v2/key-value-stores/NpvgdYoKm28QhbrG7/records/german-case-law-output.png)

![BGH data protection rulings with full text: headnote and cited norms](https://api.apify.com/v2/key-value-stores/NpvgdYoKm28QhbrG7/records/german-case-law-fulltext.png)

#### Ready-made example tasks

- **New Federal Labour Court (BAG) rulings alert**: court `BAG`, alert mode on. Schedule it daily or weekly.
- **BGH rulings on data protection (Datenschutz)**: keyword `Datenschutz`, court `BGH`, newest first, with full text.
- **Federal Finance Court (BFH) tax rulings**: court `BFH`, decisions since 1 January 2025, newest first.

### How to use it

1. Enter **keywords** (German; all words must appear in the decision), or switch **Mode** to *Lookup* and paste ECLIs or file numbers.
2. Optionally pick **courts**, **decision types** (judgment / order) and a **date range**.
3. Turn on **Include full text** if you need the decision text.
4. For alerts, turn on **Only new decisions since last run** and add a [schedule](https://docs.apify.com/platform/schedules) (e.g. every morning). Each saved search keeps its own state in a named key-value store, so you only receive new rulings.

#### Example input – keyword search

```json
{
  "keywords": "Datenschutz Schadensersatz",
  "courts": ["BGH", "BAG"],
  "dateFrom": "2024-01-01",
  "includeFullText": true,
  "maxResults": 50
}
```

#### Example input – weekly alert for new BAG rulings

```json
{
  "courts": ["BAG"],
  "decisionTypes": ["judgment"],
  "onlyNew": true,
  "alertWindowDays": 90,
  "stateKey": "bag-judgments"
}
```

#### Example input – lookup

```json
{ "eclis": ["ECLI:DE:BGH:2016:130416UVIIIZR198.15.0"], "fileNumbers": ["VIII ZR 198/15"] }
```

### Output

One dataset item per decision:

```json
{
  "jurisdiction": "DE",
  "source": "NeuRIS",
  "sourceId": "KORE303742016",
  "ecli": "ECLI:DE:BGH:2016:130416UVIIIZR198.15.0",
  "court": "BGH",
  "courtLabel": "Bundesgerichtshof (Federal Court of Justice)",
  "chamber": "8. Zivilsenat",
  "decisionDate": "2016-04-13",
  "documentType": "Urteil",
  "fileNumbers": ["VIII ZR 198/15"],
  "title": "BGH, Urteil vom 13. April 2016 - VIII ZR 198/15",
  "subject": "(Wohnraummiete: Mietminderungsanspruch bei Entwendung einer ... Vermietereinbauküche)",
  "matchSnippets": [{ "section": "headnote", "text": "Zur Mietminderung im Falle der Entwendung ..." }],
  "fullText": { "headnote": "...", "operativePart": "...", "facts": "...", "reasons": "..." },
  "normReferences": ["BGB § 535 Abs 1 S 1", "BGB § 536 Abs 1 S 1"],
  "previousDecisions": ["LG Berlin, Urteil vom 4. August 2015 - 63 S 378/14"],
  "url": "https://testphase.rechtsinformationen.bund.de/gerichtsentscheidungen/KORE303742016",
  "isNew": false,
  "retrievedAt": "2026-10-26T11:10:00Z",
  "attribution": "Source: Rechtsinformationen des Bundes ... retrieved 2026-10-26 ..."
}
```

`fullText`, `normReferences`, `previousDecisions`, `subsequentDecisions` and `keywords` are only filled when **Include full text** is on. Each run also saves a `SUMMARY` record with counts per court and the query used.

### Pricing

Pay per event, with Apify platform costs included:

| Apify plan (Store discount tier) | Price per court decision | Per 1,000 |
|---|---|---|
| Free, Starter (Bronze) | $0.001 | $1 |
| Scale (Silver) | $0.0009 | $0.90 |
| Business (Gold) and above | $0.0008 | $0.80 |

Each run also has an **Actor start** charge of $0.00005 (at the default 256 MB memory). Full text doesn't cost extra per decision, but it makes runs a little slower.

**Worked examples (Free/Starter prices):**

- **Research search returning 200 decisions:** $0.00005 + 200 × $0.001 = **about $0.20**.
- **Weekly alert with about 20 new rulings a week:** 4 runs × $0.00005 + 80 × $0.001 = **about $0.08 a month**.
- **Bulk export of 1,000 decisions for a RAG index:** $0.00005 + 1,000 × $0.001 = **about $1.00**.

The **Apify Free plan includes $5 of platform usage every month** (see [apify.com/pricing](https://apify.com/pricing)), and pay-per-event charges are paid from that credit. That covers about 5,000 decisions a month, for example a daily alert for a whole month or one large export (30 daily runs add only $0.0015 in start charges). Use **Max results** and Apify's maximum cost per run to cap spend.

### Use via API (Python, JavaScript, cURL)

You can start the Actor from your own code with the official [Apify API clients](https://docs.apify.com/api/client). Get your API token from **Apify Console → Settings → API & Integrations**.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("orange_briefcase_hrj/german-case-law-search").call(run_input={
    "keywords": "Mietminderung",
    "courts": ["BGH"],
    "maxResults": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Install with `pip install apify-client`.

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('orange_briefcase_hrj/german-case-law-search').call({
    keywords: 'Mietminderung',
    courts: ['BGH'],
    maxResults: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install with `npm install apify-client`.

#### cURL

This runs the Actor and returns the dataset items in the same request (best for short runs):

```bash
curl -X POST "https://api.apify.com/v2/acts/orange_briefcase_hrj~german-case-law-search/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": "Mietminderung", "courts": ["BGH"], "maxResults": 20}'
```

For longer runs, call `POST /v2/acts/orange_briefcase_hrj~german-case-law-search/runs` and read the dataset when the run finishes. You can also add the Actor to Zapier, Make, n8n or a webhook from the **Integrations** tab.

### Data source, licence and attribution

- **Source**: [Rechtsinformationen des Bundes](https://testphase.rechtsinformationen.bund.de) – the federal legal information portal (*NeuRIS*), operated by DigitalService GmbH des Bundes on behalf of the Bundesministerium der Justiz und für Verbraucherschutz. [API documentation](https://docs.rechtsinformationen.bund.de/).
- **Copyright**: court decisions and official headnotes are official works with no copyright protection under [§ 5 UrhG](https://www.gesetze-im-internet.de/urhg/__5.html).
- **Attribution**: every record includes an `attribution` field naming the source and the **retrieval date**. Please keep it when you republish data.
- **Test phase**: the official service is still in a test phase and its dataset is incomplete. Fields may change, and coverage is federal courts only, not state (Länder) courts. For authoritative citations, always check the official source linked in `url`.
- The Actor respects the documented rate limit of 600 requests per minute and waits between requests by default.

This Actor is not affiliated with or endorsed by the German federal government.

### Personal data and responsible use

The courts anonymise published decisions before release. This Actor **does not output the names of participating judges** and has **no judge-profiling or outcome-prediction features**. Don't use the data to re-identify parties or to profile individual judges. If you republish decisions, you are responsible for complying with GDPR.

### Related tools

Other tools from the same publisher, all built on official open-data APIs:

| Tool | What it does |
|---|---|
| [UK Public Tender Alerts](https://apify.com/orange_briefcase_hrj/uk-tender-alerts) | Daily alerts for new UK government tenders and contract awards from Find a Tender and Contracts Finder. |
| [UK Company Check & Change Monitor](https://apify.com/orange_briefcase_hrj/uk-company-check) | Bulk Companies House checks with a RED/AMBER/GREEN risk flag, plus a monitor mode that outputs only changes. |
| [Sweden Job Ads API (Platsbanken)](https://apify.com/orange_briefcase_hrj/sweden-job-ads-platsbanken) | Swedish job ads from Arbetsförmedlingen's official JobTech API, with English labels and daily alerts. |
| [Netherlands Public Tender Alerts (TenderNed)](https://apify.com/orange_briefcase_hrj/netherlands-tender-alerts) | Daily alerts for new Dutch government tenders from TenderNed, filtered by keyword, CPV and province. |

### FAQ

**Does it cover state courts (OLG, LG, AG)?** Not yet. The official API currently covers federal courts. Lower-court decisions only appear as references in `previousDecisions`.

**How does alert mode decide what's new?** It checks decisions dated within the last *alert window* days (default 90, because courts often publish weeks after the decision date). It returns any it hasn't returned before for the same search. State is stored in the named key-value store (`stateStoreName`) under `stateKey`.

**Can I start an alert without receiving the backlog?** Yes. Turn on *First alert run: mark existing as seen*.

**Is there an English translation?** The decisions are in German. The field names and court labels are in English.

Spotted an issue or want another country? Open an issue on the Actor's Issues tab.

**Where can I see what changed?** See the Changelog tab. Each release is listed there.

# Changelog

This Actor's version history is a separate document: https://apify.com/orange_briefcase_hrj/german-case-law-search/changelog.md

# Actor input Schema

## `jurisdictions` (type: `array`):

Countries to search. Germany (DE, federal courts) is available now; France and the Netherlands are planned.

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

Search by keywords and filters, or look up specific decisions by ECLI / file number. Leave empty to choose automatically.

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

Full-text search in German. All words must appear in the decision, e.g. "Mietminderung Schimmel" or "Datenschutz Schadensersatz".

## `courts` (type: `array`):

Limit to these courts. Empty = all federal courts.

## `decisionTypes` (type: `array`):

Judgments (Urteil), orders (Beschluss) or other types. Empty = all.

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

Decision date from (YYYY-MM-DD).

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

Decision date to (YYYY-MM-DD).

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

Order of results. Alert mode always uses newest first.

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

European Case Law Identifiers, e.g. ECLI:DE:BGH:2016:130416UVIIIZR198.15.0

## `fileNumbers` (type: `array`):

Court file numbers, e.g. VIII ZR 198/15. Add a single court above to narrow ambiguous numbers.

## `includeFullText` (type: `boolean`):

Add headnote, operative part (Tenor), facts, reasons, norms cited and previous decisions. One extra API call per decision.

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

Maximum decisions to save in this run (you pay per decision saved).

## `onlyNew` (type: `boolean`):

Schedule the Actor daily or weekly and get only decisions it has not returned before for this search. State is kept in a named key-value store.

## `alertWindowDays` (type: `integer`):

In alert mode, check decisions dated within this many days (courts often publish weeks after the decision date).

## `firstRunBaselineOnly` (type: `boolean`):

If on, the first alert run saves nothing and only records the current decisions, so later runs return just genuinely new rulings.

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

Named key-value store that remembers which decisions were already returned.

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

Optional name for this alert. Defaults to a hash of the search, so different searches keep separate state.

## `requestIntervalSecs` (type: `number`):

Politeness delay. The API allows 600 requests per minute per IP.

## Actor input object example

```json
{
  "jurisdictions": [
    "DE"
  ],
  "mode": "search",
  "keywords": "Datenschutz Schadensersatz",
  "sort": "newest",
  "includeFullText": false,
  "maxResults": 50,
  "onlyNew": false,
  "alertWindowDays": 90,
  "firstRunBaselineOnly": false,
  "stateStoreName": "case-law-alerts-state",
  "requestIntervalSecs": 0.2
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "mode": "search",
    "keywords": "Datenschutz Schadensersatz"
};

// Run the Actor and wait for it to finish
const run = await client.actor("orange_briefcase_hrj/german-case-law-search").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 = {
    "mode": "search",
    "keywords": "Datenschutz Schadensersatz",
}

# Run the Actor and wait for it to finish
run = client.actor("orange_briefcase_hrj/german-case-law-search").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 '{
  "mode": "search",
  "keywords": "Datenschutz Schadensersatz"
}' |
apify call orange_briefcase_hrj/german-case-law-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,orange_briefcase_hrj/german-case-law-search"
        }
    }
}
```

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/6suP3UiDysEecSaH5/builds/kdaARig8nkodTbW1v/openapi.json