# German Insolvency Check — Bulk Name Screening (`us0r/insolvenz-check-de`) Actor

Check company or personal names against Germany's official insolvency register (insolvenzbekanntmachungen.de). One row per name checked — found or not — with the court, file number, register entry and the derived state of the proceeding. Built for bulk screening of customer lists.

- **URL**: https://apify.com/us0r/insolvenz-check-de.md
- **Developed by:** [us0r](https://apify.com/us0r) (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 $20.00 / 1,000 name checkeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## German Insolvency Check — Screen Names Against the Official Register

Give this Actor a list of names. It queries Germany's official insolvency
register (`insolvenzbekanntmachungen.de`, run by the Bundesamt für Justiz) and
returns **one row per name checked** — including the names with no entry.

That shape is the point. A screening run over a customer list is mostly
"nothing found", and that answer is what you need on file.

### What you get per name

| Field | Example |
|---|---|
| `abfrage`, `suchbegriff` | `Musterbau GmbH`, `*Musterbau GmbH*` |
| `gefunden` | `true` / `false` |
| `anzahlVerfahren`, `anzahlBekanntmachungen` | `1`, `3` |
| `mehrdeutig` | `true` when the name matched more than one debtor |
| `status`, `laeuft` | `eroeffnet`, `true` — only when exactly one proceeding matched |
| `letzteBekanntmachung` | `2026-07-10` |
| `verfahren[]` | one entry per matched proceeding, see below |
| `zuVieleTreffer`, `unvollstaendig` | the portal's 1,000-hit cap, made visible |
| `geprueftAm` | ISO timestamp of the check |

Each entry in `verfahren[]`:

| Field | Example |
|---|---|
| `aktenzeichen`, `gericht` | `258 IN 49/25`, `Dortmund` |
| `schuldner`, `sitz` | `Pflegedienst HAVA GmbH`, `Dortmund` |
| `registereintrag` | `Dortmund, HRB 35222` — the commercial-register entry, when the court states one |
| `status`, `laeuft`, `statusQuelle`, `statusBeleg` | `masseunzulaenglichkeit`, `true`, `2026-07-10`, the sentence it was read from |
| `ersteBekanntmachung`, `letzteBekanntmachung` | `2025-09-16`, `2026-07-10` |
| `bekanntmachungen[]` | every announcement of that proceeding, newest first |

### The state of a proceeding, and how it is derived

The register publishes decisions, not statuses. This Actor reads the official
text of the most recent announcement of a proceeding and derives one of:

`antrag_gestellt` · `eroeffnet` · `masseunzulaenglichkeit` · `verteilung` ·
`schlusstermin` · `insolvenzplan_bestaetigt` · `aufgehoben` · `eingestellt` ·
`abgewiesen_mangels_masse` · `restschuldbefreiung_erteilt` ·
`restschuldbefreiung_versagt` · `verfahren_offen` · `unklar`

`laeuft` condenses that to true / false / null. Every derived state ships with
`statusBeleg`, the sentence it came from, and `statusQuelle`, the date of the
announcement — so the judgement is checkable rather than asserted.

If the newest announcement is a side note, the Actor reads up to two older ones
before giving up. Measured on file number 258 IN 49/25 (Dortmund): the newest
publication was a notice of insufficiency of the estate, the opening decision
sat one step below it.

### Three things that make this work

1. **No time limit for company proceedings.** The two-week restriction of § 2
   InsBekV applies, per the portal's own documentation, to pure consumer
   insolvencies opened from 26 March 2018 — those need the court in addition to
   the name. Everything else is searchable by name back to 1999, and this Actor
   queries with an open date range. Measured 18 August 2026: a name search
   returned announcements from 2022.
2. **One name, several debtors.** "Pflegedienst Ha" matched 13 announcements
   belonging to 5 different proceedings. Announcements are therefore grouped by
   court plus file number, and a single overall `status` is only reported when
   exactly one proceeding matched. Otherwise `mehrdeutig` says so.
3. **The 1,000-hit ceiling is handled, not hidden.** The portal silently caps
   long result lists. A capped query is repeated once per federal state and
   merged; if a single state still exceeds the cap, the row is flagged
   `unvollstaendig` instead of quietly returning less.

### Input

```json
{
  "abfragen": [
    "Musterbau GmbH",
    {"name": "Schmidt", "vorname": "Peter", "ort": "München", "bundesland": "BY"}
  ],
  "suchmodus": "enthaelt",
  "statusErmitteln": true,
  "volltext": false
}
```

| Option | Default | Meaning |
|---|---|---|
| `abfragen` | — | Names to check; string or object with `vorname`, `ort`, `bundesland` |
| `suchmodus` | `enthaelt` | `enthaelt` / `beginntMit` / `exakt` |
| `statusErmitteln` | `true` | Derive the state of each proceeding (one extra request each) |
| `maxVerfahrenJeAbfrage` | `10` | How many proceedings per name get a state |
| `volltext` | `false` | Fetch and parse the complete official text of every announcement |
| `maxVolltexteJeAbfrage` | `20` | Ceiling so a common name cannot run up a bill |
| `beiZuVielenTreffern` | `aufteilen` | Split a capped query by federal state, or just flag it |
| `pauseSekunden` | `0.2` | Delay before each portal request |

With `volltext: true` every announcement also carries the parsed fields of the
sister Actor: administrator with address, phone and email, deadline for filing
claims, distributable amount, registered office, date of birth for consumer
cases.

### Speed

A name costs **two portal requests and about 0.6 seconds** (measured 18 August
2026: ten names in 6.4 seconds). Deriving the state adds one request per
proceeding found. A list of 5,000 names runs in roughly an hour.

Plain HTTP against the portal — no headless browser.

### Limits, honestly

- **A name match is not an identity match.** Two companies can share a name, and
  the register writes people as "Breiter Birgitt" as often as "Birgitt Breiter".
  Use `ort` and `bundesland` to narrow, and read `mehrdeutig` before acting.
- **Consumer proceedings from 26 March 2018** drop out of the free search two
  weeks after publication. To find those later the portal requires the
  insolvency court on top of the name — pass `bundesland` and expect gaps.
- **The derived state is a reading of free text**, not a field the courts
  publish. That is why `statusBeleg` is included. For anything with consequences,
  read `bekanntmachungen[]`, or switch on `volltext`.
- **This is not a credit report.** It reports what the official register says on
  the day you ask, nothing more.

### Personal data

Consumer insolvency announcements contain names, dates of birth and full home
addresses. This Actor queries the register for a name you supply and keeps no
index of its own — every run goes to the source. Processing the results is
subject to the GDPR and to the deletion periods of § 3 InsBekV.

### Related Actors

- **[German Insolvency Announcements](https://apify.com/us0r/insolvenzbekanntmachungen-de)**
  — the other direction: read the whole stream as it is published, all 16 states
  and 193 courts, with the full text and parsed fields. Use it to monitor, use
  this one to check a list you already have.
- **[German Foreclosure Auctions](https://apify.com/us0r/zwangsversteigerungen-de)**
  — court-ordered property auctions with dates, addresses and appraised values.
  Some are filed by the insolvency administrator of a case you will find here.
- **[German Government Auctions](https://apify.com/us0r/government-auctions-de)**
  — what public authorities sell off on zoll-auktion.de and justiz-auktion.de:
  bids, closing times, pickup addresses and named contacts at 611 authorities.

### Pricing

Pay per event:

| Event | What it covers |
|---|---|
| `actor-start` | once per run |
| `abfrage` | one name checked — charged whether or not it was found |
| `treffer-volltext` | one announcement fetched in full, only with `volltext: true` |

You pay per name on your list, not per hit. A screening run costs the same
whether the register comes back empty or not, which is what makes it usable for
bulk checks.

***

Keywords: Insolvenz, Insolvenzcheck, Insolvenzabfrage, Insolvenzbekanntmachungen,
insolvency check Germany, German insolvency register, debtor screening, credit
risk Germany, KYC Germany, company verification, Bonitätsprüfung, Handelsregister
insolvency status, Insolvenzverfahren prüfen.

# Actor input Schema

## `abfragen` (type: `array`):

One entry per name. Either a plain string ("Musterbau GmbH") or an object with more detail: {"name": "Schmidt", "vorname": "Peter", "ort": "München", "bundesland": "BY"}. The extra fields narrow a common name and are what breaks the portal's 1,000-hit ceiling.

## `suchmodus` (type: `string`):

How the name is matched. "enthaelt" wraps it in wildcards and is the safest for company names, which courts write with varying legal-form suffixes.

## `statusErmitteln` (type: `boolean`):

Reads the official text of the most recent announcement of each proceeding and derives whether it is still running. Costs one extra portal request per proceeding. Turn off for a pure hit/no-hit screening.

## `maxVerfahrenJeAbfrage` (type: `integer`):

Only the most recent N proceedings of a name get a state. All proceedings are returned either way.

## `volltext` (type: `boolean`):

Fetches the complete announcement text for every hit and parses out administrator, deadlines and amounts. One extra request per announcement, billed separately.

## `maxVolltexteJeAbfrage` (type: `integer`):

Upper bound so a common name cannot run up a bill.

## `beiZuVielenTreffern` (type: `string`):

The portal caps every result list at 1,000 hits. "aufteilen" repeats the query once per federal state (16 requests) and merges; "melden" simply flags the record.

## `pauseSekunden` (type: `number`):

Politeness delay towards the portal.

## Actor input object example

```json
{
  "abfragen": [
    "Pflegedienst HAVA GmbH",
    {
      "name": "Schmidt",
      "ort": "München"
    }
  ],
  "suchmodus": "enthaelt",
  "statusErmitteln": true,
  "maxVerfahrenJeAbfrage": 10,
  "volltext": false,
  "maxVolltexteJeAbfrage": 20,
  "beiZuVielenTreffern": "aufteilen",
  "pauseSekunden": 0.2
}
```

# Actor output Schema

## `checks` (type: `string`):

One row per name checked, including the ones with no match.

## `hits` (type: `string`):

The same run reduced to court, file number, debtor and the derived state.

# 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 = {
    "abfragen": [
        "Pflegedienst HAVA GmbH",
        {
            "name": "Schmidt",
            "ort": "München"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("us0r/insolvenz-check-de").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 = { "abfragen": [
        "Pflegedienst HAVA GmbH",
        {
            "name": "Schmidt",
            "ort": "München",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("us0r/insolvenz-check-de").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 '{
  "abfragen": [
    "Pflegedienst HAVA GmbH",
    {
      "name": "Schmidt",
      "ort": "München"
    }
  ]
}' |
apify call us0r/insolvenz-check-de --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,us0r/insolvenz-check-de"
        }
    }
}

```

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/fJAbtmhlie2ucHjCS/builds/Q4kXZg4FSeL9F2lkm/openapi.json