# Austria Ediktsdatei Insolvency Scraper (`steadfetch/austria-ediktsdatei-monitor`) Actor

Austria's official insolvency register (Ediktsdatei): structured edicts as JSON - court, case number, proceeding type, debtor company, Firmenbuch number, dates. Watchlist monitor with real delta between runs. For creditor monitoring and insolvency alerts. Legal entities only; no natural persons.

- **URL**: https://apify.com/steadfetch/austria-ediktsdatei-monitor.md
- **Developed by:** [Steadfetch](https://apify.com/steadfetch) (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 $1.20 / 1,000 edict delivereds

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

## Austria Ediktsdatei Insolvency Scraper

Tested daily. Last verified: 2026-10-30

Structured Austrian insolvency edicts from the official Ediktsdatei
(`edikte.justiz.gv.at`): court, case number, proceeding type, debtor company,
Firmenbuch number, opening date, filing deadline and first hearing date. One row
per edict, in a stable schema, with an optional Firmenbuch monitor.

Public data only. No login, no CAPTCHA, no paywall, no browser.

### What it does

The Ediktsdatei is Austria's official court edict portal. It is an IBM Domino
application with no public API and no exportable search: the only way in is the
public form and one HTML page per edict. This Actor reads the same public search
a person would use and returns structured rows:

- **Search mode** - a debtor name or keyword, with optional court, proceeding
  type and opening-date filters; returns the matching edicts up to `maxRows`.
- **Monitor mode** - a watchlist of `{ "firmenbuchNr": "FN 621689z" }` items;
  each run checks every item and delivers only edicts never seen before.
  Edicts are immutable, so a quiet check delivers 0 rows and bills no result.
  `maxRows` caps the *total* new rows delivered by the run, not the checks:
  every watchlist item is always checked and billed once, even when an earlier
  item already filled `maxRows`. Rows beyond the cap stay unseen for the next
  run.

It saves a buyer the manual paging, the rotating detail links and the daily
re-checking, and it gives filterable, structured output that the official site
does not export.

#### Fields

`court`, `caseNumber`, `proceedingType`, `debtorCompany`, `firmenbuchNr`,
`address`, `openedAt`, `registrationDeadline`, `meetingDate`, `sourceUrl`, plus
the common `url` / `scrapedAt` envelope and `changeType` (`new` in monitor runs,
otherwise `null`). Dates are always ISO 8601 (`YYYY-MM-DD`); a field the edict
does not publish is `null`, never invented.

**Privacy guardrail:** only legal entities are delivered (GmbH, OG, KG, AG, SE).
Notices about natural persons - including registered sole traders (`e.U.`) and
`Inhaber` entries - are filtered out with a log counter and never become a
dataset item (company manual rule 2, GDPR). The Masseverwalter block (name,
address, phone, email) is never extracted, and no personal-name field exists in
the schema.

#### Input

Search mode:

```json
{
  "mode": "search",
  "simQuery": "Elektrotechnik",
  "court": "",
  "proceedingType": "Konkursverfahren",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-12-31",
  "maxRows": 100,
  "strictSchema": true
}
```

Monitor mode:

```json
{
  "mode": "monitor",
  "watchlist": [{ "firmenbuchNr": "FN 621689z" }],
  "maxRows": 200,
  "strictSchema": true
}
```

Dates accept ISO `YYYY-MM-DD` or the Austrian `dd.mm.yyyy`; output dates are
always ISO. `simQuery` is the debtor name field of the simple search. An empty
`simQuery` with no `dateFrom` browses every edict the site keeps, capped by
`maxRows`. The `dateFrom` / `dateTo` filters apply to the proceeding opening
date (`openedAt`).

### Example output

```json
{
  "url": "https://edikte.justiz.gv.at/edikte/id/idedi8.nsf/suchedi?SearchView&subf=f",
  "sourceUrl": "https://edikte.justiz.gv.at/edikte/id/idedi8.nsf/0/285b7e54c343fc4ec1258e6b0073b1db!OpenDocument",
  "court": "HG Wien",
  "caseNumber": "2 S 125/26h",
  "proceedingType": "Konkursverfahren",
  "debtorCompany": "A&A Elektrotechnik GmbH",
  "firmenbuchNr": "FN 621689z",
  "address": "Odoakergasse 22/2, 1160 Wien",
  "openedAt": "2026-09-08",
  "registrationDeadline": "2026-10-20",
  "meetingDate": "2026-11-03",
  "changeType": null,
  "scrapedAt": "2026-10-25T13:00:00.000Z"
}
```

### Pricing

Pay per event, no subscription:

- **1.50 USD per 1,000 results** (edicts delivered) - charged by the platform
  through `apify-default-dataset-item`, the only per-result charge. Rows
  rejected by the output schema are not pushed and not charged.
- **0.05 USD per 1,000 checks** (watchlist items) - charged through the reserved
  `monitor-check` event once per watchlist Firmenbuch number actually checked in
  a monitor run. Search runs never charge this event.
- **0.00005 USD per run start** - the Apify-recommended `apify-actor-start`
  price, which also includes the first 5 seconds of compute.

Works on the Apify free plan - about 3,333 results for the $5 monthly credit.

**Measured cost:** about 0.002 USD per 1,000 edicts locally (256 MB, plain HTML,
no proxy, no browser), leaving a wide margin. Each result costs one detail
request; at the enforced one request per second, a 100-row query takes roughly
two minutes locally.

### FAQ

**Does it need an API key?** No. The Ediktsdatei search and edict pages are
public and server-rendered.

**Does it use a browser or proxies?** No. Plain HTTP + Cheerio, at most one
request per second, honest User-Agent.

**Why are natural-person notices missing?** By design. Insolvency records of
natural persons (including `e.U.` sole traders) are personal data and out of
scope. Only legal entities with a Firmenbuch number are delivered.

**Is this legal?** The source is a public official court portal. `robots.txt`
returns a meta-refresh page with no rules, which means no path is disallowed
(CAUTION-low, recorded honestly). The Impressum lists the BMJ and the
Bundesrechenzentrum as publishers and contains no anti-scraping clause. The
Actor never logs in, never touches paid content and never requests a path that
robots.txt or the terms restrict.

**Can I monitor several companies?** Yes: put one `firmenbuchNr` item per
company, optionally with a court or proceeding-type filter. `FN 621689z` and
`621689z` are both accepted.

### Local fixture run

The committed HTML under `test/fixtures/` reproduces the live markup captured
on 2026-10-25. To run the whole Actor with `apify run`, offline and without
spending platform credit:

```bash
EDIKT_FIXTURE_DIR=test/fixtures \
  npx -y apify-cli run --purge --input-file test/fixtures/input.json
```

The saved listing declares 7 entries: 5 legal entities are delivered and the 2
natural-person notices are filtered with the usual log counter. The fixture
directory holds a `manifest.json` that maps the search page and each edict UNID
to its saved HTML. `EDIKT_FIXTURE_DIR` only swaps the HTTP client for files on
disk: the canonical `edikte.justiz.gv.at` URLs, the host allowlist and the
parsers remain the production code, and no request leaves the machine. The
variable is never set in production.

### Maintenance

- Tested daily by Steadfetch against the live portal with the registered default
  input; failures are reported before customers see them.
- If the Domino result table or the detail page markup changes, the run fails
  with a clear message instead of delivering wrong rows. Steadfetch repairs
  published Actors before starting new builds.
- Tested daily, output-schema validated on every run (`strictSchema` defaults to
  true).
- The saved fixtures are synthetic but reproduce the live markup captured on
  2026-10-25, so tests stay fast, offline and free of personal data.

# Actor input Schema

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

search returns the edicts matching the filters. monitor checks each watchlist Firmenbuch number and delivers only edicts never seen before.

## `simQuery` (type: `string`):

Debtor name or keyword, at least 3 characters (the Ediktsdatei simple search). Empty with no dateFrom browses every edict the site keeps.

## `court` (type: `string`):

Optional case-insensitive filter on the court name, for example "HG Wien" or "Landesgericht".

## `proceedingType` (type: `string`):

Optional case-insensitive filter on the proceeding type, for example "Konkursverfahren" or "Sanierungsverfahren".

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

Lower bound of the proceeding opening date (YYYY-MM-DD or dd.mm.yyyy). Empty means no lower bound.

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

Upper bound of the proceeding opening date (YYYY-MM-DD or dd.mm.yyyy). Empty means no upper bound.

## `watchlist` (type: `array`):

Required in monitor mode. One check is billed per watchlist item per run. Each item: { "firmenbuchNr": "FN 621689z" } (court and proceedingType are optional filters).

## `maxRows` (type: `integer`):

Maximum number of validated edicts to push to the dataset.

## `strictSchema` (type: `boolean`):

Fail the run when an item does not match the OUTPUT schema. Keep enabled: Steadfetch never publishes Actors without output-schema validation.

## Actor input object example

```json
{
  "mode": "monitor",
  "simQuery": "Elektrotechnik",
  "court": "HG Wien",
  "proceedingType": "Konkursverfahren",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-10-30",
  "watchlist": [
    {
      "firmenbuchNr": "FN 621689z"
    }
  ],
  "maxRows": 100,
  "strictSchema": true
}
```

# Actor output Schema

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

Dataset items validated against the item schema in dataset_schema.json (fields).

# 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",
    "simQuery": "Elektrotechnik",
    "court": "",
    "proceedingType": "",
    "dateFrom": "",
    "dateTo": "",
    "watchlist": [],
    "maxRows": 10,
    "strictSchema": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadfetch/austria-ediktsdatei-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 = {
    "mode": "search",
    "simQuery": "Elektrotechnik",
    "court": "",
    "proceedingType": "",
    "dateFrom": "",
    "dateTo": "",
    "watchlist": [],
    "maxRows": 10,
    "strictSchema": True,
}

# Run the Actor and wait for it to finish
run = client.actor("steadfetch/austria-ediktsdatei-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 '{
  "mode": "search",
  "simQuery": "Elektrotechnik",
  "court": "",
  "proceedingType": "",
  "dateFrom": "",
  "dateTo": "",
  "watchlist": [],
  "maxRows": 10,
  "strictSchema": true
}' |
apify call steadfetch/austria-ediktsdatei-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadfetch/austria-ediktsdatei-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/UQUQcX2JE5ccNqEy1/builds/LwlcNwhjBxmymJB2e/openapi.json