# Open Legal Data (Germany) (remote · de.openlegaldata.io)

German court decisions (Rechtsprechung) and laws (Gesetze) with citation graph and citation checks.

- Trust score: 71/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `de.openlegaldata.io`: 71/100 (this document), [markdown](https://verifymcp.io/servers/io-openlegaldata-de/de.md), [page](https://verifymcp.io/servers/io-openlegaldata-de/de)

## Channel facts

- Endpoint: `https://de.openlegaldata.io/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.16.5`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 74/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5104 tokens (~268/item across 19 items; 19 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 37/100
  - Stability observed for 11 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 20 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Open Legal Data (Germany) MCP server?

Open Legal Data (Germany) is a hosted endpoint at https://de.openlegaldata.io/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http io-openlegaldata-de 'https://de.openlegaldata.io/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "io-openlegaldata-de": {
      "url": "https://de.openlegaldata.io/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "io-openlegaldata-de": {
      "type": "http",
      "url": "https://de.openlegaldata.io/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.io-openlegaldata-de]
url = "https://de.openlegaldata.io/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "io-openlegaldata-de": {
      "type": "remote",
      "url": "https://de.openlegaldata.io/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add io-openlegaldata-de --url 'https://de.openlegaldata.io/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  io-openlegaldata-de:
    url: "https://de.openlegaldata.io/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "io-openlegaldata-de": {
      "Transport": "http",
      "Url": "https://de.openlegaldata.io/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add io-openlegaldata-de -t streamable-http -u 'https://de.openlegaldata.io/mcp'
```

### Other

```json
{
  "mcpServers": {
    "io-openlegaldata-de": {
      "type": "http",
      "url": "https://de.openlegaldata.io/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-19 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-15 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-13 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-11 (score 67, +1)

- [security] Tool “filter_cases” rewrote its description, which is the text the model reads
- [security] Tool “get_case_statistics” rewrote its description, which is the text the model reads
- [security] Tool “get_court” rewrote its description, which is the text the model reads
- [security] Tool “list_law_books” rewrote its description, which is the text the model reads
- [security] Tool “search_cases” rewrote its description, which is the text the model reads
- [security] Tool “search_laws” rewrote its description, which is the text the model reads
- [security] Tool “search_legal” rewrote its description, which is the text the model reads
- [security] Tool “submit_feedback” rewrote its description, which is the text the model reads
- [functional improvement] Stability: unverified → 0.03

### 2026-11-10 (score 66)

First indexed and scored.

## MCP tools (19)

### `get_server_instructions` (~22 tokens)

Get server instructions

Return MCP server instructions (if any). Always call first.

### `get_court` (~125 tokens)

Get court details

Get detailed information about a specific court.

        Look up a court by ID, slug, or code. Returns full details including
        address, contact information, and case count.

        Args:
            court_id: Court database ID.
            slug: Court slug (e.g. "ag-charlottenburg").
            code: Court ECLI code (e.g. "AGBECH" for the Amtsgericht
                Charlottenburg, "BGH").

Input parameters:

- `code` (string)
- `court_id` (integer)
- `slug` (string)

### `list_courts` (~372 tokens)

List courts

Browse and filter German courts.

        Returns a list of courts matching the given filters. Use this to
        discover which courts are available before searching for cases.

        Args:
            court_type: Filter by court type code (e.g. "AG", "LG", "OLG",
                "BGH", "VG", "OVG", "BVerwG", "ArbG", "LAG", "BAG").
            state: Filter by state name or slug (e.g. "Berlin", "bayern").
            jurisdiction: Filter by jurisdiction. Accepts the English
                shortcuts "ordinary", "administrative", "labor", "social",
                "fiscal", "constitutional" or the stored German values
                ("Arbeitsgerichtsbarkeit", …). The Bundespatentgericht
                (BPatG) belongs to ``ordinary``; there is no separate
                patent-jurisdiction category — filter on
                ``court_type="BPatG"`` if you specifically want patent
                cases.
            level_of_appeal: Filter by court level. Accepts the English
                shortcuts "local", "regional", "high", "federal" or the
                stored German values ("Amtsgericht", …).
            search: Search court names and aliases.
            limit: Maximum results to return (default 50, max 100). Values
                above 100 are clamped; the response then includes
                ``limit_clamped: true`` and the original ``requested_limit``.

Input parameters:

- `court_type` (string)
- `jurisdiction` (string)
- `level_of_appeal` (string)
- `limit` (integer)
- `search` (string)
- `state` (string)

### `filter_cases` (~359 tokens)

Filter court decisions

Structured filtering of court cases using the database.

        Unlike search_cases (which uses full-text search), this tool filters
        cases using exact database fields. Returns case metadata without
        full content, newest first, with ``total`` and ``has_more``. If an
        exact count takes too long, ``total`` is a lower bound and
        ``total_is_lower_bound`` is true. A filter combination too broad to
        answer in time (e.g. a rare ``decision_type`` without court or date
        filter) returns an ``error`` with a ``hint`` to narrow it.

        Args:
            court_id: Filter by court database ID.
            court_slug: Filter by court slug (e.g. "bgh").
            date_after: Cases from this date onward (YYYY-MM-DD).
            date_before: Cases up to this date (YYYY-MM-DD).
            file_number: Exact file number (Aktenzeichen).
            ecli: Exact ECLI identifier.
            decision_type: Decision type (e.g. "Urteil", "Beschluss").
            limit: Maximum results (default 20, max 50). Values above 50
                are clamped; the response then includes
                ``limit_clamped: true`` and the original ``requested_limit``.
            offset: Skip first N results for pagination (default 0).

Input parameters:

- `court_id` (integer)
- `court_slug` (string)
- `date_after` (string)
- `date_before` (string)
- `decision_type` (string)
- `ecli` (string)
- `file_number` (string)
- `limit` (integer)
- `offset` (integer)

### `get_case` (~302 tokens)

Get court decision

Retrieve a court case by ID or slug.

        By default returns the case metadata and the complete, untruncated
        ``content`` as plain text (HTML tags removed, entities decoded,
        whitespace normalized; one line per paragraph, Randnummern as line
        prefix). To read a long decision piece by piece, request a snippet
        with ``offset`` and/or ``length``; both count characters of that
        plain text. In snippet mode ``content`` is omitted and a ``snippet``
        object is returned:
        ``text``, ``offset``, ``length``, ``total_length``, ``has_more`` and
        ``next_offset``. Pass ``next_offset`` as ``offset`` to continue
        reading until ``has_more`` is false.

        Args:
            case_id: Case database ID.
            slug: Case URL slug.
            offset: Start position in plain-text characters (default 0).
            length: Number of plain-text characters to return. 0 (default)
                means "until the end". Leave both at 0 for the full content.
            full_text: Deprecated and ignored (content is never truncated).
                Passing it adds a ``deprecation_warnings`` entry to the
                response.

Input parameters:

- `case_id` (integer)
- `full_text`
- `length` (integer)
- `offset` (integer)
- `slug` (string)

### `get_case_statistics` (~346 tokens)

Get court decision statistics

Get aggregated case statistics.

        Returns case counts grouped by time period, optionally filtered
        by court, state, or jurisdiction.

        Without ``date_after`` only the **last 12 months** are counted.
        For counts over a longer period ("per year since 2018"), pass
        ``date_after`` (e.g. "2018-01-01") together with ``group_by="year"``.
        The response's ``date_range`` shows the period that was counted.

        Args:
            court_id: Filter by court ID.
            state: Filter by state name or slug.
            jurisdiction: Filter by jurisdiction. Accepts the English
                shortcuts ("ordinary", "labor", …) or the stored German
                values ("Ordentliche Gerichtsbarkeit", …).
            date_after: Count cases from this date (YYYY-MM-DD, default:
                365 days ago).
            date_before: Count cases up to this date (YYYY-MM-DD, default: today).
            group_by: Time grouping: "month" (default) or "year".

        Returns an ``{"error": ...}`` payload (instead of silently zero
        results) when an unknown court_id, state, jurisdiction, group_by,
        or malformed date is supplied — the previous behavior swallowed
        bad inputs as ``total: 0`` and was the dangerous failure mode
        called out in the MCP audit.

Input parameters:

- `court_id` (integer)
- `date_after` (string)
- `date_before` (string)
- `group_by` (string)
- `jurisdiction` (string)
- `state` (string)

### `get_similar_cases` (~173 tokens)

Find similar court decisions

Find court cases textually similar to a given case.

        Seeds an Elasticsearch "more like this" query with the full text of
        the given case and returns the most similar OTHER cases, ranked by
        similarity. Useful for comparative research: once you have one
        on-point decision, surface neighbouring case law without crafting a
        keyword query. For keyword- or citation-scoped neighbours instead,
        use search_cases.

        Args:
            case_id: The database ID of the seed case.
            limit: Maximum results (default 10, max 50). Values above 50 are
                clamped; the response then includes ``limit_clamped: true``
                and the original ``requested_limit``.

Input parameters:

- `case_id` (integer, required)
- `limit` (integer)

### `search_cases` (~667 tokens)

Search court decisions

Full-text search for German court cases via Elasticsearch.

        Returns matching cases (with ``file_number``) and highlighted
        snippets. Does NOT return full case text - use get_case to retrieve
        complete content.

        The citation filters compose with ``query`` so you can answer
        "cases citing § 823 BGB that mention 'Mietrecht'" in one call —
        pass ``query="Mietrecht"`` together with ``cited_law_book="bgb"``
        and ``cited_law_section="823"``. For "give me ALL citing cases"
        without keyword refinement, prefer the dedicated
        ``get_cases_for_law`` / ``get_citing_cases`` tools.
        ``cited_case_id`` is mutually exclusive with the law citation
        filter — if both are supplied, the law filter wins.

        Args:
            query: Search query text (supports Lucene syntax).
            court_code: Filter by court code (e.g. "BGH", "BVerfG").
            start_date: Filter cases from this date (YYYY-MM-DD).
            end_date: Filter cases up to this date (YYYY-MM-DD).
            decision_type: Filter by decision type (e.g. "Urteil", "Beschluss").
            cited_law_book: Restrict to cases citing a law from this
                book slug (e.g. "bgb"). Requires ``cited_law_section``.
            cited_law_section: Restrict to cases citing this law section
                slug, as in the ``slug`` of get_law_section (e.g. "823" for
                § 823 BGB, "art-14" for Art. 14 GG). Requires
                ``cited_law_book``.
            cited_case_id: Restrict to cases citing the case with this id.
            sort: Result order — "relevance" (default), "date" (newest
                first), or "most_cited" (most-cited first, for finding
                landmark precedent). The response echoes the applied
                ``sort``; any other value returns an error. Each result
                carries ``citing_cases_count`` so you can see how often it
                is cited. With relevance sort each…

Input parameters:

- `cited_case_id` (integer)
- `cited_law_book` (string)
- `cited_law_section` (string)
- `court_code` (string)
- `decision_type` (string)
- `end_date` (string)
- `limit` (integer)
- `query` (string, required)
- `sort` (string)
- `start_date` (string)

### `get_law_section` (~463 tokens)

Get law section

Get the full text of a specific law section.

        Retrieve law text by book code and section number, or by law ID.
        For example, get_law_section(book_code="BGB", section="823") returns
        the text of section 823 of the German Civil Code.

        By default the complete, untruncated ``content`` is returned as plain
        text (HTML tags removed, entities decoded, whitespace normalized; one
        line per paragraph or list item). Set ``offset`` and/or ``length`` to
        get a ``snippet`` of that plain text instead (see get_case for the
        snippet fields and pagination via ``next_offset``).

        Args:
            book_code: Law book code (e.g. "BGB", "StGB", "GG").
            section: Section identifier. Accepts bare numbers ("823",
                "20", "16a") or prefixed forms ("§ 823", "§823",
                "Art. 14", "Art 14", "Artikel 1"). The prefix spelling
                does not have to match the book: "Art. 20", "Artikel 20"
                and "20" all find Art 20 GG. Only exact sections match,
                never a longer number that contains the input. The
                ``section`` field on the response is whatever the DB
                stores, which differs by book convention: BGB / StGB /
                ZPO etc. store ``§ N`` (e.g. ``"§ 823"``), article-based
                books store e.g. ``"Art 1"`` (GG) or ``"Art. 6"``
                (DSGVO).
            law_id: Direct law database ID (alternative to book_code+section).
            offset: Start position in plain-text characters (default 0).
            length: Number of plain-text characters to return. 0 (default)
                means "until the end". Leave both at 0 for the full content.

Input parameters:

- `book_code` (string)
- `law_id` (integer)
- `length` (integer)
- `offset` (integer)
- `section` (string)

### `list_law_books` (~231 tokens)

List law books

List available German law books (e.g. BGB, StGB, GG).

        Returns law books with their codes, titles, and section counts.
        Use this to discover what legislation is available before searching
        for specific law sections.

        Args:
            latest_only: Only show latest revisions (default True).
            search: Search book codes and titles. Best matches come first
                (exact code, code prefix, code part, whole word in the
                title, part of a title word); ``match`` on each result says
                which. If ``search`` is exactly a book code, titles that only
                contain it inside a longer word (e.g. "BGBl." for "BGB")
                are left out.
            limit: Maximum results (default 50, max 200). Values above 200
                are clamped; the response then includes
                ``limit_clamped: true`` and the original ``requested_limit``.

Input parameters:

- `latest_only` (boolean)
- `limit` (integer)
- `search` (string)

### `search_laws` (~183 tokens)

Search laws

Full-text search across law sections via Elasticsearch.

        Returns matching law sections with highlighted snippets. Does NOT
        return full text - use get_law_section to retrieve the complete
        content of a specific section.

        Args:
            query: Search query text (supports Lucene syntax).
            book_code: Optional filter by law book code, any case (e.g.
                "BGB", "BranntwMonG"). An unknown code returns an error
                with ``suggestions`` instead of an empty result.
            limit: Maximum results (default 10, max 50). Values above 50 are
                clamped; the response then includes ``limit_clamped: true``
                and the original ``requested_limit``.

Input parameters:

- `book_code` (string)
- `limit` (integer)
- `query` (string, required)

### `get_case_references` (~72 tokens)

Get references in a decision

Get forward references FROM a case (what this case cites).

        Returns all laws and cases that the given case references in its
        text. Useful for understanding the legal basis of a decision.

        Args:
            case_id: The database ID of the case.

Input parameters:

- `case_id` (integer, required)

### `get_cases_for_law` (~257 tokens)

Find decisions citing a law

Find all cases that cite a specific law section.

        Returns cases that reference the given statute section in their
        text. Useful for understanding how courts interpret a specific
        provision. To narrow the citing set by keyword, court, or date,
        use ``search_cases(query=..., cited_law_book=..., cited_law_section=...)``
        instead.

        Args:
            book_code: Law book code (e.g. "BGB", "StGB").
            section: Section identifier (e.g. "823").
            law_id: Direct law database ID (alternative to book_code+section).
            sort: "date" (default, newest first) or "most_cited" — the
                latter surfaces the landmark decisions interpreting this
                provision (most-cited first).
            limit: Maximum results (default 20, max 50). Values above 50 are
                clamped; the response then includes ``limit_clamped: true``
                and the original ``requested_limit``.

Input parameters:

- `book_code` (string)
- `law_id` (integer)
- `limit` (integer)
- `section` (string)
- `sort` (string)

### `get_citing_cases` (~193 tokens)

Find decisions citing a decision

Get reverse references TO a case (cases that cite this case).

        Find all cases that reference the given case in their text.
        Useful for understanding the impact and precedent value of a
        decision. To narrow the citing set by keyword, court, or date,
        use ``search_cases(query=..., cited_case_id=case_id)`` instead.

        Args:
            case_id: The database ID of the cited case.
            sort: "date" (default, newest first) or "most_cited" (the most
                influential citing cases first).
            limit: Maximum results (default 20, max 50). Values above 50 are
                clamped; the response then includes ``limit_clamped: true``
                and the original ``requested_limit``.

Input parameters:

- `case_id` (integer, required)
- `limit` (integer)
- `sort` (string)

### `validate_citation` (~151 tokens)

Validate legal citation

Check if a legal citation exists in the OLDP database.

        Validates Aktenzeichen (file numbers), ECLI identifiers, or
        paragraph references (e.g. "§ 823 BGB"). Use this to verify
        citations before presenting them to users.

        Args:
            citation: The citation to validate (e.g. "VI ZR 123/22",
                "ECLI:DE:BGH:2023:...", "§ 823 BGB").
            citation_type: Type hint: "auto" (default), "file_number",
                "ecli", or "law_reference".

Input parameters:

- `citation` (string, required)
- `citation_type` (string)

### `submit_feedback` (~294 tokens)

Send feedback to OLDP

Send feedback about OLDP or this MCP server to the OLDP team.

        Use this to report bugs (wrong results, errors, broken tools),
        problems with the legal data (missing or wrong decisions, laws or
        references), or to request features. Only submit feedback the user
        wants to send or has agreed to; do not include personal data or
        confidential case details. Requires a signed-in connection (OAuth or
        API token); anonymous calls are answered with HTTP 401 and an OAuth
        challenge, so the client can offer the user to sign in.

        Args:
            category: One of ``feature_request``, ``bug_report``,
                ``data_issue`` or ``other``.
            message: The feedback itself, in English or German
                (20-5000 characters). For bugs, describe what you did, what
                you expected and what happened instead.
            subject: Optional one-line summary (max 200 characters).
            context: Optional technical context (max 2000 characters), e.g.
                the tool name and arguments involved, case IDs, ECLI or law
                references.

        Returns:
            ``{"submitted": true, ...}`` on success, otherwise ``{"error": ...}``.

Input parameters:

- `category` (string, required)
- `context` (string)
- `message` (string, required)
- `subject` (string)

### `get_platform_info` (~60 tokens)

Get platform coverage

Get OLDP platform coverage summary.

        Returns an overview of the data available on the Open Legal Data
        Platform, including counts of cases, laws, courts, and references.
        Call this first to understand what data you can search and retrieve.

### `search_legal` (~342 tokens)

Search laws and court decisions

Search BOTH legislation and court cases in one call.

        Returns the most relevant law sections AND court decisions for the
        query, **grouped by type**. Use this when a legal question may be
        answered by statute or by case law and you don't yet know which —
        e.g. "ortsübliche Vergleichsmiete" surfaces § 558 BGB *and* BGH
        decisions together. For type-specific control (citation filters,
        court/date filters), use ``search_cases`` / ``search_laws``.

        Matching is on the words of the text: a law section is found only
        if it contains the query terms. Colloquial terms that the statute
        doesn't use (e.g. "Eigenbedarf"; § 573 BGB says "die Räume als
        Wohnung für sich ... benötigt") find case law but not that section.
        Then search with the statute's wording, or read the cases' cited
        sections via ``get_case_references``.

        Results are grouped rather than merged into one ranked list on
        purpose: court decisions are long and out-score short statute
        texts on relevance, so a naive merged ranking returns only cases
        and buries the on-point law.

        Args:
            query: Search query text (supports Lucene syntax and "phrases").
            limit: Max results per type (default 5, max 25). Values above 25
                are clamped; the response then includes ``limit_clamped:
                true`` and the original ``requested_limit``.

Input parameters:

- `limit` (integer)
- `query` (string, required)

### `whoami` (~316 tokens)

Show connection and rate limit

Show who you are connected as and your remaining request budget.

        Call this before a long task to check how many requests are left,
        or to learn how to get a larger budget. Every HTTP request to the
        MCP server counts against the budget, including this call; once
        nothing is left, requests (this one too) are rejected with HTTP 429
        until the window frees up. Returns:

        - ``authenticated``: whether the connection is signed in.
        - ``user``: ``username`` and ``profile_complete``, or null.
        - ``auth_method``: ``oauth``, ``api_token``, ``legacy_token`` or
          ``session``; null when anonymous.
        - ``rate_limit``: ``tier`` (``anonymous``, ``registered``,
          ``enriched`` or ``custom``), ``bucket`` (``shared`` when all
          anonymous users of this connector share one budget, ``ip`` or
          ``user``), ``limit`` per ``window_seconds``, ``used``,
          ``remaining``, and ``retry_after_seconds`` once nothing is left.
          Signed-in users share one budget between MCP and the REST API.
        - ``upgrade``: how to get a larger budget (``action``, ``url``,
          ``limit``, ``message``), or null. Pass the ``message`` and
          ``url`` on to the user when the budget is too small for the task.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/io-openlegaldata-de/de#diagnostics

## Score history

- 2026-11-21: 71
- 2026-11-20: 71
- 2026-11-19: 71
- 2026-11-18: 70
- 2026-11-17: 70
- 2026-11-16: 69
- 2026-11-15: 69
- 2026-11-14: 68
- 2026-11-13: 68
- 2026-11-12: 67
- 2026-11-11: 67
- 2026-11-10: 66

## Common questions

### What is the Open Legal Data (Germany) MCP server?

Open Legal Data (Germany) is an MCP server listed in the public MCP registry as io.openlegaldata/de. German court decisions (Rechtsprechung) and laws (Gesetze) with citation graph and citation checks. This page covers its hosted endpoint (https://de.openlegaldata.io/mcp).

### Is the Open Legal Data (Germany) MCP server safe to use?

Open Legal Data (Germany) scores 71 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Open Legal Data (Germany) MCP server expose?

Open Legal Data (Germany) exposes 19 tools: get_server_instructions, get_court, list_courts, filter_cases, get_case, and 14 more. Their descriptions and schemas cost roughly 4,928 tokens of context every time the server is loaded.

### Does the Open Legal Data (Germany) MCP server require authentication?

No. We connected to Open Legal Data (Germany) without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Open Legal Data (Germany) MCP server still maintained?

Open Legal Data (Germany) is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the Open Legal Data (Germany) MCP server?

VerifyMCP ran 13 checks on Open Legal Data (Germany), covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://de.openlegaldata.io/mcp
- Repository: https://github.com/openlegaldata/oldp
- Website: https://de.openlegaldata.io/
- Changelog RSS feed: https://verifymcp.io/servers/io-openlegaldata-de/de.xml
- Changelog JSON feed: https://verifymcp.io/servers/io-openlegaldata-de/de/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/io-openlegaldata-de/de.json
- HTML version of this page: https://verifymcp.io/servers/io-openlegaldata-de/de
