# Czech Insolvency Register / ISIR / Insolvenční rejstřík IČO (`original-nativy/isir-insolvency-monitor`) Actor

Monitor Czech companies by IČO in the official ISIR insolvency register (insolvenční rejstřík) and get only newly published insolvency events. Run it daily on a schedule for automatic insolvency alerts on your debtors, clients, suppliers and counterparties.

- **URL**: https://apify.com/original-nativy/isir-insolvency-monitor.md
- **Developed by:** [Milan Novák](https://apify.com/original-nativy) (community)
- **Categories:** Lead generation, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 new insolvency events

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/actors/running/actors-in-store.md#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

Monitor Czech companies in the **ISIR insolvency register** — the official **insolvenční rejstřík** at [isir.justice.cz](https://isir.justice.cz) — by **IČO**, and get **only the newly published insolvency events**. Run it on a schedule for **daily insolvency alerts** on your debtors, clients, suppliers, or counterparties.

> *Sleduje český **insolvenční rejstřík (ISIR)** podle **IČO** a hlásí jen nové insolvenční události — ideální pro každodenní monitoring obchodních partnerů.*

### What does the Czech Insolvency Register Monitor do?

You give it a **watchlist of Czech company IČO numbers**. On every run it looks each company up in the official **insolvenční rejstřík (ISIR)** and returns the insolvency-proceeding events for those companies — the insolvency petition (**insolvenční návrh**), the decision on bankruptcy (**úpadek**), declared bankruptcy (**konkurs**), reorganization (**reorganizace**), published court documents, and more.

In its **`new-only` mode** it remembers what it already reported and returns **only events that are new since the last run**. That makes it a true **change monitor** for the Czech insolvency register, not a one-off export: schedule it daily and each run gives you just the fresh filings — ideal for **credit-risk, receivables, factoring, legal, and compliance** teams who need to know the moment a business partner enters insolvency.

- **Official source**, no API key required — reads the public ISIR register (insolvenční rejstřík) directly.
- **Watchlist by IČO** — track many companies (subjekty) in one run.
- **New-events-only** deduplication across scheduled runs.
- **Built-in spend caps** — hard per-run and per-proceeding limits so a big case can't surprise you with a large bill.
- **No wasted cost** — companies with no insolvency history return nothing and are not charged.

### Why use it?

- **Early warning on debtors.** Learn about a customer's insolvency the day it is published in the insolvenční rejstřík, not when the receivable defaults.
- **Portfolio monitoring.** Watch an entire book of counterparties (podle IČO) with one scheduled Actor.
- **Feed your systems.** Push events straight into a spreadsheet, CRM, or database via the Apify API and [integrations](https://apify.com/integrations) (Make, Zapier, webhooks, Slack, Google Drive…).
- **Cheap and fast.** Static HTML parsing (Cheerio) — see the pricing section.

### How to use it

1. Open the Actor and go to the **Input** tab.
2. Paste your company **IČO** numbers into **Company IČO watchlist** (8 digits each).
3. Leave **Mode** on **New events only (monitor)** for alerts, or switch to **All events (full snapshot)** for a one-time export.
4. (Optional) Set **Only events since (date)** to backfill just a recent window on your first run instead of an entire multi-year proceeding.
5. Click **Start**. For daily alerts, open the **Schedule** tab and add a schedule (see below).

### Input

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Company IČO watchlist | `icoList` | array of strings | – (required) | Czech company IČO numbers to monitor in the insolvency register. |
| Mode | `mode` | `new-only` | `all` | `all` | `all` returns every event (great for a first run); switch to `new-only` for scheduled monitoring — it returns only events unseen within the dedup window. |
| Dedup window (days) | `dedupWindowDays` | integer | `30` | In `new-only` mode, an event already reported within this many days is skipped and **not** charged. |
| Only events since (date) | `sinceDate` | string (ISO `YYYY-MM-DD`) | – (off) | Drop events published before this date **before** dedup and **before** charging. Use it to backfill a sensible window (e.g. last 90 days) on the first run. |
| Register sections | `sections` | array of `A/B/C/D/P` | `["A","B"]` | Which ISIR sections (oddíly) to include. A = up to bankruptcy (do úpadku), B = after bankruptcy (po úpadku), C = incidental disputes, D = other, P = creditor claims (přihlášky). |
| Max results (spend cap) | `maxResults` | integer | `200` | Hard cap on events returned **and charged** per run, so you control spend. At **$4.00 / 1,000 events** the default caps a run at ≈ **$0.80**. `0` = unlimited. |
| Max events per proceeding (spend cap) | `maxEventsPerSubject` | integer | `50` | Cap on events charged per single proceeding, so one large multi-year case can't consume the whole run budget and starve the rest of your watchlist. `0` = unlimited. |
| Dedup state store name | `stateKvsName` | string | `isir-monitor-state` | Named key-value store holding the "already-alerted" IDs between runs. Use different names to run independent watchlists on one account. |
| Proxy configuration | `proxyConfiguration` | object | proxy off | ISIR is public and works without a proxy; enable Apify Proxy only if you hit rate limits. |

#### Example input

```json
{
    "icoList": ["25083325", "26863154"],
    "mode": "new-only",
    "sections": ["A", "B"],
    "sinceDate": "2024-01-01",
    "dedupWindowDays": 30,
    "maxResults": 200,
    "maxEventsPerSubject": 50
}
```

### Output

Each pushed item is a single insolvency event. You can download the dataset in **JSON, CSV, Excel, HTML, or XML**, or fetch it via the API.

#### Output fields

| Field | Description |
|---|---|
| `ico` | Company IČO the event belongs to. |
| `nazev` | Debtor name (název) as recorded in ISIR. |
| `spisovaZnacka` | Case reference (spisová značka), e.g. `KSOS 25 INS 10525 / 2016`. |
| `court` | Court conducting the proceeding (soud). |
| `stavRizeni` | Current state of the proceeding (stav řízení), e.g. `Povolena reorganizace`. |
| `section` | ISIR section (oddíl): `A`, `B`, `C`, `D`, or `P`. |
| `datePublished` | When the event was published in ISIR (local time). |
| `popis` | Event description (in Czech, as published). |
| `idUdalosti` | Event ID within the proceeding. |
| `documentUrl` | Direct link to the published PDF document, when available. |
| `datumPravniMoci` | Date the document became legally effective (nabytí právní moci), when available. |
| `detailUrl` | Link to the full proceeding on isir.justice.cz. |
| `scrapedAt` | ISO timestamp of the run. |

#### Example output records

The insolvency petition (**insolvenční návrh**) that opened the OKD reorganization — a real record from a run:

```json
{
    "ico": "26863154",
    "nazev": "Správa pohledávek OKD, a.s.",
    "spisovaZnacka": "KSOS 25 INS 10525 / 2016",
    "court": "Krajského soudu v Ostravě",
    "stavRizeni": "Povolena reorganizace",
    "section": "A",
    "datePublished": "2016-05-03T14:32",
    "popis": "Insolvenční návrh spojený s návrhem na povolení reorganizace",
    "idUdalosti": "I_7",
    "documentUrl": "https://isir.justice.cz/isir/doc/dokument.PDF?id=23076275",
    "datumPravniMoci": null,
    "detailUrl": "https://isir.justice.cz/isir/ueu/evidence_upadcu_detail.do?id=3BD92F3EAA724B37ACCEDD86B31BE055",
    "scrapedAt": "2026-08-24T12:20:26.238Z"
}
```

A later section-B ruling from the same proceeding, showing a populated `datumPravniMoci`:

```json
{
    "ico": "26863154",
    "nazev": "Správa pohledávek OKD, a.s.",
    "spisovaZnacka": "KSOS 25 INS 10525 / 2016",
    "court": "Krajského soudu v Ostravě",
    "stavRizeni": "Povolena reorganizace",
    "section": "B",
    "datePublished": "2016-05-11T11:05",
    "popis": "Usnesení o vydání předběžného opatření",
    "idUdalosti": "I_85",
    "documentUrl": "https://isir.justice.cz/isir/doc/dokument.PDF?id=23383505",
    "datumPravniMoci": "2016-06-08",
    "detailUrl": "https://isir.justice.cz/isir/ueu/evidence_upadcu_detail.do?id=3BD92F3EAA724B37ACCEDD86B31BE055",
    "scrapedAt": "2026-08-24T12:20:26.238Z"
}
```

### Pricing

This Actor uses **pay-per-event** pricing: you are charged **only for each new insolvency event returned**.

| What you pay for | Price |
|---|---|
| Each insolvency event returned | **$0.004 per event** ($4.00 per 1,000 events) |

Because it monitors changes, **healthy companies on your watchlist cost effectively nothing** — no insolvency record means no events and no per-event charge. A typical daily run over a watchlist yields only the handful of genuinely new filings, so ongoing monitoring stays cheap. The built-in **Max results** and **Max events per proceeding** caps mean a first run — or a single huge historical case — can never bill more than you expect. Underlying platform compute is minimal: a run producing 1,000 events uses about **0.0023 compute units**.

### Run it on a schedule (recommended)

Scheduled monitoring is the whole point — this Actor is designed to be run **daily** so each run reports only what changed:

1. Open the Actor's **Schedule** tab (or [Schedules](https://console.apify.com/schedules) in the Console).
2. Create a schedule, e.g. every day at 07:00, pointing at this Actor with your saved input.
3. Add a notification: connect a **[webhook](https://docs.apify.com/platform/integrations/webhooks)**, Slack, email, or Make/Zapier integration so new events reach your inbox or systems automatically.

Keep **Mode** on `new-only` and set **Dedup window (days)** to at least your schedule interval (30 days is a safe default). The dedup state persists between scheduled runs, so you never get the same alert twice. On the **first** run, set **Only events since (date)** to backfill just a recent window instead of an entire proceeding's history.

### FAQ & notes

- **Where does the data come from?** The public ISIR insolvency register (insolvenční rejstřík) at isir.justice.cz. This Actor only reads publicly available register data.
- **Which sections should I monitor?** `A` (proceedings up to bankruptcy / do úpadku) and `B` (after bankruptcy / po úpadku) cover what most creditors care about. Section `P` (creditor claims / přihlášky pohledávek) can be very large; enable it only if you need it — and note the per-proceeding cap.
- **How do I avoid a big first bill?** Leave the **Max results** and **Max events per proceeding** caps in place, and use **Only events since (date)** to limit history on the first run.
- **Do I need a proxy?** No. ISIR is public; leave the proxy off unless you monitor very large watchlists and hit rate limits.
- **Feedback / bugs?** Use the **Issues** tab on the Actor page.

*Disclaimer: this Actor extracts publicly available information from the official Czech insolvency register (ISIR / insolvenční rejstřík) for legitimate monitoring purposes. You are responsible for using the data in compliance with applicable law.*

# Actor input Schema

## `icoList` (type: `array`):

List of Czech company IČO numbers (8 digits) to monitor in the ISIR insolvency register. Each is looked up on isir.justice.cz. Leading zeros are kept.

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

"new-only" (the monitoring product): push only insolvency events not seen within the dedup window — run it daily on a schedule to get alerts. "all": push every event currently in the register for each IČO.

## `dedupWindowDays` (type: `integer`):

In "new-only" mode, an event whose ID was already reported within this many days is skipped (and not charged). Set to your schedule interval or longer. Ignored in "all" mode.

## `sinceDate` (type: `string`):

Optional ISO date (YYYY-MM-DD). Events published before this date are dropped before dedup and before charging, so you are never billed for them. Use it on the first run to backfill a sensible window (e.g. the last 90 days) instead of pulling an entire multi-year proceeding. Leave empty to include all events. Composes with both modes and both spend caps.

## `sections` (type: `array`):

Which ISIR sections (oddíly) to include. A = proceedings up to bankruptcy, B = after bankruptcy, C = incidental disputes, D = other, P = creditor claims. Default A+B covers the events most people care about.

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

Hard cap on the number of events pushed — and charged — per run, so you control spend. Billing is $4.00 / 1,000 events ($0.004 each), so this default of 200 caps a run at about $0.80. 0 = unlimited (use with care). Raise it for a large one-off snapshot; keep it low for scheduled daily monitoring.

## `maxEventsPerSubject` (type: `integer`):

Cap on events pushed — and charged — per individual insolvency proceeding, so one large multi-year case can't consume the whole run budget and starve the rest of your watchlist. Billing is $4.00 / 1,000 events ($0.004 each). 0 = unlimited. Applied in addition to Max results.

## `stateKvsName` (type: `string`):

Named key-value store that holds the 'already-alerted' event IDs between runs. Persists across scheduled runs (the default store does not). Use a different name to run several independent watchlists on one account without their dedup state colliding.

## `proxyConfiguration` (type: `object`):

isir.justice.cz is a public government register and usually works without a proxy. Enable Apify Proxy only if you hit rate limits.

## Actor input object example

```json
{
  "icoList": [
    "25083325",
    "26863154"
  ],
  "mode": "all",
  "dedupWindowDays": 30,
  "sections": [
    "A",
    "B"
  ],
  "maxResults": 200,
  "maxEventsPerSubject": 50,
  "stateKvsName": "isir-monitor-state",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "icoList": [
        "25083325",
        "26863154"
    ],
    "maxResults": 200,
    "maxEventsPerSubject": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("original-nativy/isir-insolvency-monitor").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 = {
    "icoList": [
        "25083325",
        "26863154",
    ],
    "maxResults": 200,
    "maxEventsPerSubject": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("original-nativy/isir-insolvency-monitor").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 '{
  "icoList": [
    "25083325",
    "26863154"
  ],
  "maxResults": 200,
  "maxEventsPerSubject": 50
}' |
apify call original-nativy/isir-insolvency-monitor --silent --output-dataset

```

## MCP server setup

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

```

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/eh7fkF1Tr8IhFMf72/builds/YwJGwEbkHUPHfYhY9/openapi.json