# Czech Company Registry (ARES) API → Clean JSON (`quietpinelabs/ares-company-profile`) Actor

Czech company data from the official ARES registry as clean, normalised JSON: profile by IČO (100 per request) or name, legal form, status, address, NACE, VAT ID, court registration, officers (opt-in), daily change feed. Pay per company returned.

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

## Pricing

from $2.10 / 1,000 company profiles

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 company data from ARES as clean JSON — by IČO, name or daily change feed

Look up Czech companies in **ARES** (Administrativní registr ekonomických subjektů, the Ministry of Finance's master business register) and get one normalised JSON record per company: legal form, status, registered address, NACE codes, VAT ID, court registration and, on request, officers, share capital and trade licences. The actor calls only the official ARES REST API (no scraping, no proxies, no API key), batches 100 IČO per request and removes natural-person data by default. Incremental mode reads ARES's daily change batches, so you only pay for companies that actually changed.

### Who uses it

- **KYC/AML and credit analysts** — verify a counterparty's IČO, legal form, VAT registration and insolvency flag before onboarding.
- **Procurement, sales and finance ops** — enrich supplier or CRM lists and keep them fresh with the change feed; works from Make, Zapier or n8n without code.
- **Data journalists and researchers** — pull every company matching a name or region into a spreadsheet.

### Use cases

**1. Enrich a list of IČO** (100 per ARES request, up to 5,000 per run):

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

One profile per IČO found; unknown or invalid IČO are listed in the `STATS` record and cost nothing.

**2. Find companies by name in a region, with the court-register extract:**

```json
{ "name": "Prazdroj", "region": "Plzeň", "includeRegisters": ["vr", "res"], "maxRecords": 200 }
```

Legal persons whose business name contains "Prazdroj" and whose seat is in a kraj, okres or obec matching "Plzeň", with court registration, share capital, previous names and prevailing NACE.

**3. Watch a portfolio for changes** (schedule daily):

```json
{ "icos": ["45274649", "00006947"], "mode": "incremental", "includeRegisters": ["vr"] }
```

The first run returns the current profiles as a baseline; later runs return only the companies that appear in ARES's change batches since the previous run.

### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `icos` | string\[] | `["45274649","00006947"]` | IČO to look up (1–8 digits, zero-padded, checksum-validated). Up to 5,000 per run. |
| `name` | string | – | Business-name full-text search (`obchodniJmeno`). Legal persons only. ARES rejects searches matching more than 1,000 entities. |
| `region` | string | – | Name-search filter: diacritics-insensitive substring of the kraj, okres or obec of the seat ("Praha" also matches okres Praha-východ; use "Hlavní město Praha" for the capital only). |
| `dateFrom`, `dateTo` | date | – | Name search: `establishedOn` range. Incremental: release-date range of change batches (`dateFrom` also bootstraps a run without a cursor). |
| `includeRegisters` | string\[] | `[]` | Opt-in extracts, one extra request per register and company: `vr` (court register: registration, share capital, previous names, officers), `rzp` (active trade licences), `res` (prevailing NACE), `ros` (data-box ID), `ceu` (insolvent-debtor cases). |
| `includeOfficers` | boolean | `true` | With `vr` and an IČO you supplied: current statutory-body members as name, role and dates. |
| `mode` | `full` / `incremental` | `full` | See *Incremental mode*. |
| `maxRecords` | integer | `1000` | Stop after this many profiles. |

Both `icos` and `name` may be given; IČO lookups run first, then the name search fills up to `maxRecords`.

### Output

One `CompanyProfile` per company. Real record from the default input (local run on 2026-10-18; NACE and registration lists shortened):

```jsonc
{
  "country": "CZ", "id": "45274649", "idType": "ico",
  "name": "ČEZ, a. s.", "kind": "legal-person",
  "legalForm": { "code": "121", "label": "Akciová společnost" },
  "status": "active",
  "registeredAddress": { "street": "Duhová", "houseNumber": "1444/2", "city": "Praha", "cityPart": "Michle", "postalCode": "14000", "region": "Hlavní město Praha", "country": "CZ", "formatted": "Duhová 1444/2, 14000 Praha, CZ" },
  "nace": { "other": [
    { "code": "35.11", "label": "Production of electricity", "section": "D", "raw": "35110" },
    { "code": "35.14", "label": "Trade of electricity", "section": "D", "raw": "35140" }
    // … 24 more codes
  ] },
  "vatId": "CZ45274649", "otherIds": { "dic": "CZ45274649", "icoId": "45274649" },
  "establishedOn": "1992-05-06",
  "registrations": [
    { "register": "Veřejný rejstřík", "registerCode": "vr", "number": "B 1581", "court": "Městský soud v Praze" },
    { "register": "Registr plátců DPH", "registerCode": "dph" }
    // … ROS, RES, RŽP, RED
  ],
  "previousNames": [],
  "provenance": {
    "source": "ares",
    "sourceName": "ARES – Administrativní registr ekonomických subjektů, Ministerstvo financí ČR",
    "sourceUrl": "https://ares.gov.cz/ekonomicke-subjekty?ico=45274649",
    "licence": "Zdroj: ARES, Ministerstvo financí ČR (https://ares.gov.cz). Public-sector open data; …",
    "retrievedAt": "2026-10-18T01:57:26.657Z", "sourceUpdatedAt": "2026-10-08"
  }
}
```

Other fields: `kind` is `legal-person`, `public-body`, `natural-person-entrepreneur` or `unknown`; `status` is `active`, `in-liquidation`, `in-insolvency` (derived from ARES register-state codes — confirm in ISIR before acting on it), `dissolved` or `unknown`; `dissolvedOn`; `nace.main` (with `res`); `officers[] { name, role, roleCode, from, to?, representation? }`, `shareCapital { amount, currency }` and `previousNames[] { name, from, to }` (with `vr`); `otherIds.dataBoxId` (with `ros`). Not-found IČO, invalid checksums, dropped records and request counts are written to the key-value store record `STATS`.

### Pricing in plain words

You pay **$3 per 1,000 company profiles returned**, plus $0.00005 per run start. Empty results are free: not-found IČO, invalid checksums, filtered-out records and unchanged companies in incremental mode are never charged. On the free plan ($5 monthly credit) that is about 1,600 profiles a month. Bronze, Silver and Gold volume discounts are configured on the store page. The run stops gracefully when it reaches `maxRecords` or your maximum total charge.

### Limits & fair use

- ARES's operating terms allow the Ministry to restrict users who send **more than 500 requests per minute**, many simultaneous queries or queries from many IP addresses. This actor sends at most **4 requests per second with 2 in flight**, batches 100 IČO per request and uses a single egress without proxies. HTTP 429/403 fails the run immediately with a clear message (no retry storm); 5xx and network errors are retried 4 times with exponential back-off.
- Name searches matching more than 1,000 entities are rejected by ARES; the run fails with a message asking for a more specific name or a `region`.
- Up to 5,000 IČO per run; each register in `includeRegisters` adds one request per company. Reaching `maxRecords` or your budget stops the run and keeps everything already pushed.

### Incremental mode

ARES publishes daily notification batches per source (VR always; RES and RŽP when selected). The cursor is kept in the run's default key-value store under `CURSOR` **and mirrored to the named key-value store `ares-company-profile-cursor`** (override with the `cursorStore` input, one per watch-list), so it survives across runs and tasks. Format: `{ "value": { "lastBatch": { "vr": 748, "res": 1234 } }, "updatedAt": "…" }` — the last batch number fully processed per source . First run with `icos`: current profiles as a baseline, cursor set to the newest batches. First run without `icos`: only the cursor is stored and nothing is charged, unless `dateFrom` is given. Later runs read every newer batch oldest-first, intersect the changed IČO with `icos` when given and return full profiles. A batch interrupted by `maxRecords` or the budget is not marked done and is re-read next time (`STATS.skippedBatchPartial`), so keep `maxRecords` above your expected daily change volume.

### Data protection

ARES is a statutory public register (Act No. 304/2013 Coll. § 7; Government Regulation No. 425/2016 Coll.) whose open-data record is declared to contain personal data. This actor minimises it by default:

- **Natural-person entrepreneurs** (fyzické osoby podnikající) are returned only when their own IČO is in `icos`, with the address reduced to municipality, region and country. Name searches and change feeds return legal persons and public bodies only.
- **Officers** appear only for companies you looked up by IČO with `vr` selected, as name, role and dates. Birth dates (`datumNarozeni`), residential addresses (`bydliste`) and nationality are never output, and a key deny-list removes them again as a last line of defence. RŽP responsible representatives and ROS statutory bodies are not output at all.
- **Rodné číslo** is never requested or output.
- The developer stores no personal data: datasets live in your Apify storage; only cursors and counters are kept.

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, procurement and journalism. You are the controller of what you download. Corrections or removals of register content must be requested from ARES or the primary register listed in `registrations`; each record's `provenance.sourceUrl` opens the entity in ARES. This section describes the actor's behaviour and is not legal advice.

### FAQ

**An IČO I know exists is reported as not found.** ARES lists only entities with a valid IČO checksum; typos appear as `invalidIcos`, genuinely missing ones as `notFoundIcos` in `STATS`. Neither is charged.

**Why are there no officers in my output?** Officers need three things: `includeRegisters` contains `vr`, `includeOfficers` is `true`, and the company's IČO was in `icos`. Name-search hits never include officers.

**The status says `in-insolvency` but the company looks fine.** The flag is derived from ARES register-state codes (CEÚ/ISIR sources, VR insolvency entries). Confirm in the insolvency register — the companion ISIR actor returns the proceeding itself.

**How fresh is the data?** The ARES API dataset is updated daily; `provenance.sourceUpdatedAt` carries the latest `datumAktualizace` across the fetched sources.

**Why does a name search return fewer companies than the ARES website?** Sole traders are dropped on name search by design, and `region`, `dateFrom` and `dateTo` filter after the search (`STATS.droppedByFilter`).

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

### Source & licence

Zdroj: ARES, Ministerstvo financí ČR (https://ares.gov.cz). Public-sector open data; informative character only ("pouze informativní charakter"). Reused under the ARES operating terms.

Operating terms: https://mf.gov.cz/cs/ministerstvo/informacni-systemy/ares. ARES data "mají pouze informativní charakter a nemohou být použity jako průkazný podklad pro soudní řízení." Each record carries the attribution in `provenance.licence`. Not affiliated with the Ministry of Finance of the Czech Republic.

### Changelog / support

- 0.1 — first public release: IČO batch lookup, name search, VR/RŽP/RES/ROS/CEÚ extracts, incremental change feed.

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, 1–8 digits; zero-padded automatically). Up to 5,000 per run, looked up 100 per ARES request. IČO with an invalid checksum or not found in ARES are listed in the STATS record and never charged.

## `name` (type: `string`):

Search by (part of) the business name (ARES `obchodniJmeno` full-text). Returns legal persons only — natural-person entrepreneurs are never returned by name. ARES rejects searches matching more than 1,000 entities; use a more specific name or add `region`.

## `region` (type: `string`):

Optional filter for name searches: substring of the kraj, okres or obec name of the registered seat (e.g. "Praha", "Jihomoravský", "Brno"). Diacritics-insensitive. Ignored for IČO lookups.

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

ISO date (YYYY-MM-DD) or DD.MM.YYYY. Name search: only companies established on/after this date. Incremental mode: only notification batches released on/after this date (also used to bootstrap a run without a cursor).

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

ISO date (YYYY-MM-DD) or DD.MM.YYYY. Name search: only companies established on/before this date. Incremental mode: only notification batches released on/before this date.

## `includeRegisters` (type: `array`):

Opt-in per-source extracts merged into the profile (one extra ARES request per register and company). `vr` = public (court) register: court registration, share capital, previous names, officers; `rzp` = trade register: active trade licences; `res` = statistical register: prevailing NACE; `ros` = basic register of persons: data-box ID; `ceu` = central register of insolvent debtors: insolvency flag and case numbers.

## `includeOfficers` (type: `boolean`):

When `vr` is in `includeRegisters` and the company was looked up by its IČO, include current statutory-body and other-organ members (name, role, dates only — never birth dates or addresses). Name searches and incremental changes of IČO you did not supply never include officers.

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

`full` returns the current profile of every matching company. `incremental` reads ARES daily change batches (VR, plus RES/RŽP when selected in `includeRegisters`) released since the previous run and returns only changed companies — restricted to `icos` when given. The cursor is stored in the run's key-value store under `CURSOR`.

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

Stop after this many company profiles (also protects your budget).

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

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

## Actor input object example

```json
{
  "icos": [
    "45274649",
    "00006947"
  ],
  "includeRegisters": [],
  "includeOfficers": true,
  "mode": "full",
  "maxRecords": 1000
}
```

# 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": [
        "45274649",
        "00006947"
    ],
    "includeRegisters": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietpinelabs/ares-company-profile").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": [
        "45274649",
        "00006947",
    ],
    "includeRegisters": [],
}

# Run the Actor and wait for it to finish
run = client.actor("quietpinelabs/ares-company-profile").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": [
    "45274649",
    "00006947"
  ],
  "includeRegisters": []
}' |
apify call quietpinelabs/ares-company-profile --silent --output-dataset

```

## MCP server setup

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

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/KPwZB98j7mXKWgQ3F/builds/4QOXbFZcelAWZ5lRK/openapi.json