# Czech Insolvency Register (ISIR) Check by IČO (`quietpinelabs/isir-insolvency-watch`) Actor

Checks Czech companies in the official insolvency register (ISIR, Ministry of Justice) by IČO and returns clean JSON per proceeding: case number, court, state, start/end dates, detail link. Incremental mode reports only changes. No name or birth-number search.

- **URL**: https://apify.com/quietpinelabs/isir-insolvency-watch.md
- **Developed by:** [Quietpine Labs](https://apify.com/quietpinelabs) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 insolvency proceedings

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

## Czech insolvency checks from ISIR as clean JSON — by IČO, with change alerts

Check whether a Czech company is in the **Insolvenční rejstřík (ISIR)**, the Ministry of Justice's official insolvency register, and get one JSON record per proceeding: case number, court, register state (raw code and normalised bucket), whether it is still active, the dates the bankruptcy decision and its termination became final, and a deep link to the case. The actor uses the Ministry's official web service, takes IČO only (so it cannot look up private individuals), never outputs birth numbers or addresses, and in `incremental` mode reports only proceedings that are new or changed since the previous run — a cheap scheduled watchlist.

### Who uses it

- **KYC/AML, credit and collections teams** — screen counterparties before a contract or loan and re-screen them daily.
- **Procurement and supplier-risk ops** — watch a supplier list for new proceedings and alert via Make, Zapier or n8n.
- **Data journalists and researchers** — track corporate insolvencies by court, state and date without a SOAP client.

### Use cases

**1. One-off screening of a counterparty list:**

```json
{ "icos": ["26863154", "25083325", "45274649"] }
```

One record per active proceeding; IČO with no proceedings produce nothing (and no charge).

**2. Full history including closed cases from a date range:**

```json
{ "icos": ["25083325"], "activeOnly": false, "dateFrom": "2015-01-01" }
```

Every proceeding the register still serves whose bankruptcy decision became final since 2015, including `closed` and `dismissed` ones.

**3. Daily watchlist (schedule as a task):**

```json
{ "icos": ["26863154", "25083325"], "mode": "incremental", "maxIcosPerRun": 500 }
```

First run: a baseline of current proceedings. Later runs: only new proceedings or state/date changes — zero records and zero cost on a quiet day.

### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `icos` (required) | string\[] | `["26863154","25083325"]` | IČO to check — the only lookup key. Normalised to 8 digits, checksum-validated, deduplicated; invalid ones are skipped and reported. |
| `activeOnly` | boolean | `true` | Register filter `filtrAktualniRizeni=T`, plus proceedings that already have a final end date or a closed state are dropped. `false` returns the full history. |
| `maxResultsPerIco` | integer 1–200 | `20` | Proceedings per IČO (`maxPocetVysledku`). |
| `dateFrom`, `dateTo` | date | – | Keep proceedings whose `startedOn` (fallback `endedOn`) is in range; proceedings with no date yet (pending petitions) are always kept. |
| `mode` | `full` / `incremental` | `full` | See *Incremental mode*. |
| `maxRecords` | integer | `1000` | Stop after this many proceedings. |
| `maxIcosPerRun` | integer 1–3000 | `500` | Cap on register requests per run (one per IČO). |

`name` and `region` are deliberately not offered.

### Output

One `InsolvencyProceeding` per proceeding. Real record from the default input (local run on 2026-10-18):

```json
{
  "country": "CZ",
  "ico": "26863154",
  "debtorName": "Správa pohledávek OKD, a.s.",
  "debtorKind": "legal-person",
  "caseNumber": "KSOS 25 INS 10525/2016",
  "court": "Krajský soud v Ostravě",
  "stateCode": "REORGANIZ",
  "state": "reorganisation",
  "isActive": true,
  "startedOn": "2016-05-09",
  "hasCoDebtors": false,
  "detailUrl": "https://isir.justice.cz/isir/ueu/evidence_upadcu_detail.do?id=3BD92F3EAA724B37ACCEDD86B31BE055",
  "dataAsOf": "2026-10-18T03:26:35.000Z",
  "provenance": {
    "source": "isir",
    "sourceName": "ISIR – Insolvenční rejstřík, Ministerstvo spravedlnosti ČR",
    "sourceUrl": "https://isir.justice.cz/isir/ueu/evidence_upadcu_detail.do?id=3BD92F3EAA724B37ACCEDD86B31BE055",
    "licence": "Zdroj: Insolvenční rejstřík, Ministerstvo spravedlnosti ČR (https://isir.justice.cz), public register under § 419 zák. č. 182/2006 Sb. Records removed under § 425 are not served.",
    "retrievedAt": "2026-10-18T01:57:28.419Z",
    "sourceUpdatedAt": "2026-10-18T03:26:35.000Z"
  }
}
```

Fields: `caseNumber` is the spisová značka built from court code, senate, type, number and year (e.g. `MSPH 95 INS 12575/2022`); `stateCode` is the register's raw code and `state` the normalised bucket — `pending` (NEVYRIZENA, MORATORIUM, NEVYR-POST, OBZIVLA, ZRUŠENO VS), `bankruptcy-declared` (ÚPADEK), `bankruptcy` (KONKURS, K-PO ZRUŠ.), `reorganisation` (REORGANIZ), `debt-relief` (ODDLUŽENÍ), `closed` or `dismissed` (VYRIZENA, PRAVOMOCNA, ODSKRTNUTA), `other` for codes not in the manual; `isActive` is true when the state is ongoing and `endedOn` is empty; `startedOn` is the date the úpadek decision became final; `dataAsOf` is the replica timestamp (the service labels it `Z` although it appears to be Czech local time; it is passed through unchanged). Erroneous entries (`MYLNÝ ZÁP.`) are dropped.

### Pricing in plain words

You pay **$4 per 1,000 proceedings returned**, plus $0.00005 per run start. Empty results are free: IČO without proceedings, invalid IČO, dropped records and unchanged proceedings in incremental mode are never charged. On the free plan ($5 monthly credit) that is about 1,200 proceedings a month. Bronze, Silver and Gold volume discounts are configured on the store page.

### Limits & fair use

- The Ministry reserves the right to block users who send **more than 3,000 requests per day or more than 50 requests per minute** (WS_2 manual § 1.3.3 and the operating terms). Apify runs share egress IPs, so this actor paces at **0.75 requests per second (45 per minute), concurrency 1**, sends one request per IČO and caps a run at `maxIcosPerRun` (default 500). Keep your total under about 2,500 IČO per day across all your tasks.
- Timing: 2 IČO take about 5 s; 500 IČO about 11–12 minutes. HTTP 429/5xx/network errors are retried with exponential back-off; application errors (`SQL1`, `SERVER1`, SOAP fault) are retried 3 times and then fail the run. Records collected before a failure stay in the dataset.
- `WS4` ("data not up to date" — the replica stopped synchronising): data returned so far is kept and flagged in the log; if the service returns WS4 without data the run fails rather than reporting a false "no insolvency".
- Reaching `maxRecords` or your budget stops the run and keeps what was pushed.

### Incremental mode

The cursor is kept in the run's default key-value store under `CURSOR` **and mirrored to the named key-value store `isir-insolvency-watch-cursor`** (override with the `cursorStore` input, one per watch-list), so it survives across runs and tasks. Format: `{ "value": { "<ico>": { "<caseNumber>": "<fingerprint>" } }, "updatedAt": "…" }`. The fingerprint is a hash of `stateCode|state|isActive|startedOn|endedOn|debtorName`, so a state change, a final end date or a renamed debtor shows up as a changed record. IČO with no proceedings are stored as empty so a future insolvency appears as *new*. The cursor is written in both modes, so a `full` baseline followed by `incremental` runs works; if a run stops early, only fully written IČO are marked as seen.

### Data protection

The insolvency register is public by law (§ 419 of Act No. 182/2006 Coll.) and lists natural-person debtors with birth numbers and home addresses. This actor is built so that it cannot reach them:

- **Lookup is by IČO only.** The web service also searches by birth number, name and date of birth; none of that is exposed. Consumers in debt relief are therefore unreachable.
- **Never output:** rodné číslo (`rc`), `datumNarozeni`, academic titles, and every address element (`druhAdresy`, `mesto`, `ulice`, `cisloPopisne`, `okres`, `zeme`, `psc`). The record is built from an explicit allow-list and then passed through a key deny-list and schema validation.
- **Natural-person entrepreneurs** appear only when you supplied their IČO; records without an IČO (e.g. a spouse found via the joint-debtor lookup) are always dropped.
- **§ 425 purge:** debtors struck from the register (5 years after the final terminating decision, 3 years after discharge in debt relief) are not served by the Ministry's service, and the actor stores no debtor data of its own — only cursor fingerprints and counters — so purged proceedings disappear from incremental output automatically. Delete purged records from your own copies.

Lawful basis for the processing inside a run is Art. 6(1)(f) GDPR — legitimate interest in making a statutorily public register machine-readable for due diligence, KYC/AML, credit and procurement checks. You are the controller of what you download. Requests concerning register content go to the insolvency court or the Ministry of Justice (technickapodpora.isir@msp.justice.cz); each record's `detailUrl` opens the proceeding. This section describes the actor's behaviour and is not legal advice.

### FAQ

**Is this SOAP? Do I need an account?** The Ministry offers insolvency data only as SOAP web services; the actor builds the envelope for you. No registration, key or account is needed.

**Can I search by company name or by a person?** No — by design. The only business identifier exposed is the IČO; name and birth-number search would reach private individuals. Look up the IČO in ARES first (companion actor).

**Does "no record" mean "no insolvency"?** Only if the run finished normally. The service reads a replica synchronised hourly (`dataAsOf`), so a petition filed in the last hour may be missing; if the replica is stale (`WS4`) the actor says so instead of returning nothing.

**Why does `activeOnly` drop a case the register calls active?** The register's own filter still returns cases in state `ÚPADEK` that already have a final end date, and `VYRIZENA` (finished) cases. The actor additionally treats a final end date as closed.

**Can I get documents, creditors or the event history?** Not from this lookup service; use `detailUrl` for the full file on isir.justice.cz.

**Who invoices me?** Apify. Usage is billed to your Apify account; the developer never sees your data or payment details.

### Source & licence

Zdroj: Insolvenční rejstřík, Ministerstvo spravedlnosti ČR (https://isir.justice.cz), public register under § 419 zák. č. 182/2006 Sb. Records removed under § 425 are not served.

Service manual: https://isir.justice.cz/isir/help/Popis_WS_2_v1_13.pdf. Data have informative character; the register may change at any time. Each record carries the attribution in `provenance.licence`. Not affiliated with the Ministry of Justice of the Czech Republic.

### Changelog / support

- 0.1 — first public release: IČO lookup via WS_2, active/history filter, incremental watch mode.

Questions, bugs and feature requests: use the **Issues** tab of this actor.

Documentation drafted with AI assistance and reviewed by the publisher before publication.

# Actor input Schema

## `icos` (type: `array`):

Czech company identifiers (IČO) to check in the insolvency register — the only lookup key. One request per IČO; invalid checksums are skipped and reported, never charged. Default: OKD (26863154) and Sberbank CZ (25083325), two public insolvencies of legal persons.

## `activeOnly` (type: `boolean`):

Return only proceedings that are still running (register filter `filtrAktualniRizeni=T`, plus proceedings with a final end date are dropped). Turn off to see closed and historical cases too.

## `maxResultsPerIco` (type: `integer`):

Passed to the register as `maxPocetVysledku`. One debtor rarely has more than a few proceedings; the service maximum/default is 200.

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

Keep proceedings whose úpadek decision became final on/after this date (YYYY-MM-DD or DD.MM.YYYY). Proceedings without any date (pending petitions) are always kept.

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

Keep proceedings whose úpadek decision became final on/before this date (YYYY-MM-DD or DD.MM.YYYY).

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

`full` returns every matching proceeding; `incremental` returns only proceedings that are new or changed (state, dates) since the previous run of this actor/task — the cursor is stored under key `CURSOR` in the run's default key-value store.

## `maxRecords` (type: `integer`):

Stop after this many proceedings have been returned (protects your budget).

## `maxIcosPerRun` (type: `integer`):

Safety cap on register requests per run. The Ministry of Justice blocks users who send more than 3,000 requests per day (or 50 per minute); this actor paces at 0.75 requests/second (45 per minute). Split larger lists across runs/days.

## `cursorStore` (type: `string`):

Named key-value store that keeps the incremental-mode cursor across runs (default `isir-insolvency-watch-cursor`). Use a different name per watch-list.

## Actor input object example

```json
{
  "icos": [
    "26863154",
    "25083325"
  ],
  "activeOnly": true,
  "maxResultsPerIco": 20,
  "mode": "full",
  "maxRecords": 1000,
  "maxIcosPerRun": 500
}
```

# Actor output Schema

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

All records returned by this run (full JSON).

## `overview` (type: `string`):

No description

## `stats` (type: `string`):

Records requested, returned and charged, plus source request counts.

# 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 = {
    "icos": [
        "26863154",
        "25083325"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietpinelabs/isir-insolvency-watch").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 = { "icos": [
        "26863154",
        "25083325",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("quietpinelabs/isir-insolvency-watch").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 '{
  "icos": [
    "26863154",
    "25083325"
  ]
}' |
apify call quietpinelabs/isir-insolvency-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quietpinelabs/isir-insolvency-watch"
        }
    }
}
```

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/v6Q3addJgv1fqlAnE/builds/YXc89lcbgi4Y3Wj28/openapi.json