# Czech Company Search (ARES) (`opendatadesk/czech-company-register`) Actor

Search official Czech company data by name, ICO, industry or municipality. Clean English fields, no login. Sole traders and officers are left out.

- **URL**: https://apify.com/opendatadesk/czech-company-register.md
- **Developed by:** [Open Data Desk](https://apify.com/opendatadesk) (community)
- **Categories:** Lead generation, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 1,000 companies

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?

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 Search (ARES)

Search the official Czech company register, or look up companies by their IČO, as clean data you can drop into a spreadsheet, a CRM or an automation in n8n, Make or Zapier. No login, no proxy, no cookies.

### What does Czech Company Search do?

It reads the public REST API of ARES, the Administrative Register of Economic Subjects, run by the Ministry of Finance of the Czech Republic. You can search by company name, look up company numbers, or filter by legal form, industry and municipality.

Typical uses:

- Enrich a list of Czech IČO numbers with name, address, legal form and VAT number.
- Find companies in an industry or a city for sales or supplier checks.
- Feed a short, stable JSON record to an AI agent or a no-code workflow.

### What data do you get?

Field names are in English, and every company is one flat row.

| Field | What it is |
| --- | --- |
| `companyNumber`, `name` | Eight digit IČO and the official name |
| `legalFormCode`, `legalForm`, `legalFormEn` | Official form code, the Czech name, and a short English name when we have one |
| `vatNumber` | VAT identification number (DIČ), when registered |
| `foundedDate`, `dissolvedDate`, `updatedDate` | Dates from the register |
| `isActive` | False if the company has a dissolution date or is no longer active |
| `industryCode`, `industryCodes` | CZ-NACE codes |
| `registeredForVat`, `inPublicRegister` | Yes/no flags from the source registers |
| `address` | Street, postal code, city, region and country |
| `status` | `ok`, or a skip reason such as `not_found` or `skipped_sole_trader` |
| `sourceUrl`, `dataSource`, `scrapedAt` | A link to the official page, the source line, and when it was read |

Missing values are `null`. Nothing is guessed.

#### Example output

One company from a test run against the official ARES register.

```json
{
    "companyNumber": "00006947",
    "name": "Ministerstvo financí",
    "legalFormCode": "325",
    "legalForm": "Organizační složka státu",
    "legalFormEn": "State organisational unit",
    "vatNumber": "CZ00006947",
    "foundedDate": null,
    "dissolvedDate": null,
    "updatedDate": "2026-03-23",
    "isActive": true,
    "industryCodes": [
        "84110"
    ],
    "industryCode": "84110",
    "taxOfficeCode": "001",
    "registeredForVat": true,
    "inPublicRegister": false,
    "address": {
        "text": "Letenská 525/15, Malá Strana, 11800 Praha 1",
        "street": "Letenská",
        "houseNumber": "525",
        "orientationNumber": "15",
        "postalCode": "11800",
        "city": "Praha",
        "cityPart": "Malá Strana",
        "district": "Praha 1",
        "region": "Hlavní město Praha",
        "country": "Česká republika",
        "countryCode": "CZ",
        "municipalityCode": "554782"
    },
    "status": "ok",
    "sourceUrl": "https://ares.gov.cz/ekonomicke-subjekty?ico=00006947",
    "dataSource": "ARES, Ministry of Finance of the Czech Republic",
    "scrapedAt": "2026-11-16T14:54:53.779Z"
}
```

### What is left out on purpose

- Sole traders and other forms that stand for a natural person are never returned as a company, because they are personal data. If you look up such an IČO, you get a row with status `skipped_sole_trader` and no name or address.
- Names of directors, statutory bodies, partners and owners are not collected.

### Nothing is silently dropped

Every company number you type in is written back. Invalid numbers, numbers that are not in the register, and sole traders stay in the results with a status. Searches that are larger than 1,000 matches are cut at that official limit, and the log tells you.

### How to use it

1. Open the Input tab.
2. Add company names, or IČO numbers, or leave both empty and use filters such as industry or municipality.
3. Set `Max companies` and click Start.
4. Download the result as JSON, CSV or Excel, or read it with the API.

### Input options

- **Company names to search**: each name is searched on its own.
- **Company numbers (IČO)**: spaces and missing leading zeros are fine.
- **Legal form codes**: for example 112 for an s.r.o. and 121 for an a.s. Empty means all company forms.
- **Industry codes**: CZ-NACE, for example `62` or `620`.
- **Municipality codes**: the official code, for example `554782` for Prague.
- **Founded in the last N days**, **Founded from**, **Founded to**: applied after the search, because the official API cannot filter by founding date itself.
- **Only active companies**.
- **Max companies**: stops after this many matching companies.

### Limits

- One search can read at most 1,000 results. If a search is bigger, the Actor tells you in the log. Narrow it with a more specific name, an industry or a municipality.
- The API may restrict users who send more than 500 requests a minute, repeat the same query, or send a large number of requests at once. This Actor waits briefly between calls and stays well below that limit.
- Founding-date filters are applied to the search results, not by the register itself.

### How much does it cost?

You pay for each row that is written, including skipped look-ups. The price per 1,000 companies is shown at the top of this page, and you can set a maximum cost per run.

### Data source and legal

The data comes from the public REST API of ARES (Administrativní registr ekonomických subjektů), operated by the Ministry of Finance of the Czech Republic. Anyone may use the services if they follow the operating terms (checked November 2026: https://data.mf.gov.cz/api/ares.html and https://ares.gov.cz/swagger-ui/). The ministry also publishes ARES open data at https://ares.gov.cz/otevrena-data/ and https://data.mf.gov.cz/.

This Actor is not made by or connected to the Ministry of Finance. You are responsible for following the operating terms and the data protection rules that apply to your use. Company data only is returned. Sole traders and officers are left out.

### Issues and requests

If a field looks wrong or you need another filter, please open an issue on the Issues tab with your input.

# Actor input Schema

## `searchTerms` (type: `array`):

Each name is searched on its own. Leave empty to look up company numbers or use the filters below.

## `companyNumbers` (type: `array`):

Look up companies by their 8 digit company number. Spaces and missing leading zeros are fine. Every number is written back, including invalid, missing and sole-trader ones.

## `legalForms` (type: `array`):

Three digit codes, for example 112 for s.r.o. and 121 for a.s. Leave empty for all company forms. Sole traders and other natural-person forms are never returned.

## `industryCodes` (type: `array`):

For example 62 or 620 for computer programming and related activities.

## `municipalityCodes` (type: `array`):

Official Czech municipality code, for example 554782 for Prague. Only the first code is used in the search.

## `foundedInLastDays` (type: `integer`):

Keep companies founded in the last N days. Applied after the search, because the official API cannot filter by founding date itself.

## `foundedFrom` (type: `string`):

Format YYYY-MM-DD. Used when 'Founded in the last N days' is 0.

## `foundedTo` (type: `string`):

Format YYYY-MM-DD.

## `onlyActive` (type: `boolean`):

Skip companies that have a dissolution date or are no longer active in the register.

## `maxItems` (type: `integer`):

Stops after this many matching companies. Requested company numbers are still written, with status skipped_limit if the cap is reached.

## Actor input object example

```json
{
  "searchTerms": [
    "Seznam"
  ],
  "companyNumbers": [
    "00006947"
  ],
  "foundedInLastDays": 0,
  "onlyActive": false,
  "maxItems": 25
}
```

# Actor output Schema

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

Dataset of companies returned by the run. Each item is one company.

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

A short JSON summary of the run, including 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 = {
    "searchTerms": [
        "Seznam"
    ],
    "companyNumbers": [
        "00006947"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("opendatadesk/czech-company-register").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 = {
    "searchTerms": ["Seznam"],
    "companyNumbers": ["00006947"],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("opendatadesk/czech-company-register").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 '{
  "searchTerms": [
    "Seznam"
  ],
  "companyNumbers": [
    "00006947"
  ],
  "maxItems": 25
}' |
apify call opendatadesk/czech-company-register --silent --output-dataset

```

## MCP server setup

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

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/0vBfMHC27ry0hWqNO/builds/OTsVJxl0uTwAMPmbt/openapi.json
