# Czech Company Check: ARES, VIES, RPO (CZ + SK) (`deriverge/czech-company-check`) Actor

Check Czech and Slovak companies in bulk against ARES, the Slovak RPO, EU VIES, and the Czech tax register. Add company IDs, VAT numbers, or names and get legal name, address, VAT validity, unreliable payer status, and the bank accounts it published with the tax office. Unmatched rows are free.

- **URL**: https://apify.com/deriverge/czech-company-check.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Business, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 company records

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

## Czech & Slovak Company Checker (ARES, VIES, RPO)

### What is Czech & Slovak Company Checker?

**Czech & Slovak Company Checker** takes a list of companies and checks each one against five official registers: ARES, the Slovak RPO, EU VIES, and ADIS, the Czech tax authority's register of VAT payers. All four are free and public. The work is in querying them in bulk, joining them on one company, and dealing with the rows where the name you have does not match the name the register has.

The part nobody else automates is the bank account. Under §109 of the Czech VAT Act, if you pay a supplier into an account that supplier never published with the tax authority, you can be made liable for the VAT that supplier then fails to pay. Those published accounts sit in ADIS. Hardly anyone checks them, because by hand it is one lookup per invoice. Give this actor the account number printed on the invoice and it tells you whether the supplier published that account, and if not, which accounts they did publish.

It also returns unreliable payer status, VAT validity from VIES, and fuzzy name to company ID matching with a confidence score. That last one matters when the supplier list came out of accounting software with names but no IČO. Rows it cannot match are not charged. What it cannot do is tell you an invoice is genuine. It tells you the account on it matches what the supplier declared, which is a narrower thing.

### The check nobody else automates

Under §109 of the Czech VAT Act, if you pay a supplier's invoice to a bank account that supplier has **not published** with the tax authority, you can be held liable for their unpaid VAT. Companies publish those accounts officially, but nobody checks invoices against them, because the data lives in a SOAP service most people never touch.

This actor joins it. Give it a company ID and the account number printed on the invoice:

```json
{ "identifier": "27082440", "bankAccount": "2171532/0800", "reference": "invoice-2026-002" }
```

and you get back:

```json
{
  "matched": true,
  "identity": { "name": "Alza.cz a.s.", "ico": "27082440", "address": "Jankovcova 1522/53, Holešovice, 17000 Praha 7" },
  "vatValid": true,
  "unreliablePayer": false,
  "publishedAccounts": ["35-3355550267/0100", "2171532/0800", "188505042/0300", "..."],
  "accountMatchesPublished": true,
  "accountChecksumValid": true,
  "riskFlags": []
}
```

Change one digit in that account number and the answer flips, with the reason spelled out:

```json
{
  "accountMatchesPublished": false,
  "accountChecksumValid": false,
  "riskFlags": [
    "ÚČET NA FAKTUŘE NENÍ MEZI ZVEŘEJNĚNÝMI: platba na nezveřejněný účet zakládá ručení za DPH dodavatele",
    "Číslo účtu neprošlo kontrolní číslicí ČNB"
  ]
}
```

That is a fraud and liability check on invoice payments, run over a whole supplier list at once.

### What gets checked, and where it comes from

| Source | What it provides |
|---|---|
| **ARES** (Ministry of Finance) | Czech company identity: name, registered address, legal form, NACE codes, VAT number, registration and dissolution dates |
| **RPO** (Slovak Statistical Office) | Slovak company identity, including full name and address history |
| **EU VIES** | Whether the VAT number is currently valid anywhere in the EU |
| **MFČR ADIS** | Unreliable-VAT-payer flag and the officially published bank accounts |
| **ISIR** (Ministry of Justice) | Insolvency proceedings: file number, court, status such as bankruptcy or debt relief, start and end dates |

Every output row carries a `provenance` block naming the register, the exact URL queried, and the timestamp, so the result is auditable rather than merely asserted.

### Insolvency is checked on every Czech row

Every Czech company is also looked up in ISIR, the official insolvency register. An open proceeding comes back as the first risk flag with the file number, the court, the status (bankruptcy, debt relief, reorganisation) and the date it started, plus a link to the court file. A closed proceeding is reported with its end date, because a supplier that went through bankruptcy three years ago is still worth a second look. An empty answer from the register is a verified "no proceedings", not a missing check.

### Input

Give it whatever you have. A company ID, a VAT number, or just a name:

```json
{
  "companies": [
    "45274649",
    { "identifier": "27082440", "bankAccount": "2171532/0800", "reference": "inv-002" },
    { "name": "deriverge s.r.o." }
  ]
}
```

- **Company IDs** are checksum-verified locally before any lookup, so a typo costs you nothing.
- **Names** are resolved with a confidence score. Legal-form suffixes and diacritics are normalised, so `NOVÁK SRO`, `Novák s.r.o.` and `Novák s. r. o.` all match. When two companies match a name almost equally well, the row is flagged for manual review instead of guessed.
- **Bank accounts** accept both the local format (`27-5868650297/0100`, leading zeros fine) and Czech IBAN.
- **`reference`** is returned unchanged, so you can join results back to your own rows.

### Watch a list for changes

Checking a supplier once is useful. Checking the same list every morning and reading only what changed is what keeps you out of trouble. Give the run a watch name (or save it as a task and schedule it) and every later run compares its results with the previous one: a company that turned inactive, a new risk flag, a VAT registration cancelled, a published account that disappeared. The differences are stored in the `CHANGES` record of the run, ready for an integration or an email. The comparison itself is free.

### Pricing

| Event | Price |
|---|---|
| Run fee, charged once per run that resolves at least one company | $0.03 |
| Company successfully matched | $0.006 |
| Each additional register joined (VAT check, payer status, account comparison, insolvency) | $0.002 |
| Company not found | **free** |

A hundred suppliers checked against all four registers cost about $1.03. The German and Swiss equivalents charge $0.81 for the same list and return neither payer reliability nor published bank accounts. Rows you cannot match cost nothing, so a messy supplier list is safe to throw at it, and a run that matches nothing costs nothing at all.

### What you get that others skip

- Unmatched companies are free. Invalid company IDs and account numbers are rejected by checksum locally, before any request is spent.
- Every value carries provenance: which register said it, at which URL, and when.
- A payment risk check nobody else automates: the invoice account is compared against the accounts the supplier published with the tax office, because paying an unpublished account creates VAT liability under Section 109 of the Czech VAT Act.
- The whole pipeline runs a live check every morning, so a register changing its format breaks our monitoring, not your run.

### Frequently asked questions

**What does an unmatched row cost?** Nothing. Rows that fail the checksum or cannot be found in any register are returned with an explanation and are never charged.

**Where does the data come from?** Five official registers: Czech ARES, the Slovak RPO, EU VIES, the Czech insolvency register ISIR and the Czech tax authority's ADIS. All values carry their source and timestamp.

**Can I mix IČO, VAT numbers and company names in one list?** Yes. Each row is recognised by its shape, and plain names are matched with a confidence score.

**What happens when a register is down?** The affected fields come back null with a note saying the check could not be performed. A source outage never fails your whole batch.

### Typical uses

- **Before paying invoices**: verify the account on the invoice is the supplier's published one
- **Onboarding suppliers or customers**: one pass over a CSV of company IDs
- **Cleaning a CRM or accounting export**: resolve names to company IDs, fill in addresses, drop dissolved companies
- **Recurring monitoring**: schedule it monthly and watch `unreliablePayer` and `publishedAccounts` for changes
- **AI agents**: call it through MCP; the output schema is declared, so the agent knows the shape before running

### What it does not collect

No directors, no owners, no personal names or contact details. Companies only. Insolvency-register data about individuals is deliberately out of scope.

### Speed, cost and reliability

All four registers are official, free, and have no anti-bot protection, so runs need no proxy and no browser. Local checksum validation on company IDs and account numbers means malformed rows never reach the network.

When a register changes its response format, the run **fails loudly** rather than returning rows with silently missing fields.

### FAQ

**Can I check a company without knowing its ID?**
Yes: pass `name`. You get the resolved company plus a `matchConfidence`, and ambiguous cases are flagged.

**What if a company has no published bank accounts?**
That is itself flagged as a risk. A VAT-registered company that has published none is unusual and worth a question.

**Does it work for Slovak companies?**
Identity yes, via the Slovak business register. The unreliable-payer flag and published accounts are Czech-specific: Slovakia maintains its own separate list, which this actor does not yet cover.

**How current is the data?**
Every query hits the live register at run time; nothing is cached. The `provenance` block records exactly when each answer was fetched.

**Something broke. How fast will it be fixed?**
Issues are answered within 12 hours.

# Actor input Schema

## `companies` (type: `array`):

One entry per company. Each can be a plain string (company ID, VAT number, or name) or an object with any of: identifier, ico, vatNumber, name, bankAccount, reference. Add bankAccount to verify an invoice account against the accounts the company officially published with the tax authority.

## `includeSlovakia` (type: `boolean`):

When a company ID is not found in the Czech ARES register, try the Slovak business register (RPO) as well.

## `allowNameMatch` (type: `boolean`):

When no company ID is given, resolve the company by name and return a confidence score. Ambiguous matches are flagged rather than guessed.

## `maxConcurrency` (type: `integer`):

How many companies to check at once. The registers are public services, so keep this modest.

## `watchKey` (type: `string`):

Give the run a name such as "suppliers" and schedule it. Every later run with the same name compares its results with the previous one and stores the differences (status changes, new risk flags, removed accounts) in the CHANGES record. Comparison is free. Runs from a saved task are compared automatically even without a name.

## Actor input object example

```json
{
  "companies": [
    {
      "identifier": "45274649",
      "reference": "invoice-2026-001"
    },
    {
      "identifier": "27082440",
      "bankAccount": "2171532/0800",
      "reference": "invoice-2026-002"
    },
    {
      "name": "deriverge s.r.o."
    }
  ],
  "includeSlovakia": true,
  "allowNameMatch": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per submitted company, with identity, VAT validity, unreliable-payer status, published bank accounts and risk flags.

## `summary` (type: `string`):

How many companies were resolved, how many were not found and therefore not charged, and how many carry a risk flag.

# 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 = {
    "companies": [
        {
            "identifier": "45274649",
            "reference": "invoice-2026-001"
        },
        {
            "identifier": "27082440",
            "bankAccount": "2171532/0800",
            "reference": "invoice-2026-002"
        },
        {
            "name": "deriverge s.r.o."
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/czech-company-check").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 = { "companies": [
        {
            "identifier": "45274649",
            "reference": "invoice-2026-001",
        },
        {
            "identifier": "27082440",
            "bankAccount": "2171532/0800",
            "reference": "invoice-2026-002",
        },
        { "name": "deriverge s.r.o." },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/czech-company-check").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 '{
  "companies": [
    {
      "identifier": "45274649",
      "reference": "invoice-2026-001"
    },
    {
      "identifier": "27082440",
      "bankAccount": "2171532/0800",
      "reference": "invoice-2026-002"
    },
    {
      "name": "deriverge s.r.o."
    }
  ]
}' |
apify call deriverge/czech-company-check --silent --output-dataset

```

## MCP server setup

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

```

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/4JTnT8h6doetkjing/builds/Am8oMwFqEWkUlRryL/openapi.json