# European Company Registry: FR, CZ, PL, FI, EE (`maliksaid/europe-company-registers`) Actor

Company registry data from France (Sirene), Czech Republic (ARES), Poland (KRS), Finland (PRH) and Estonia in one schema. Search by name, look up by company number, or get new companies daily. Legal form, status, industry code, address, VAT ID.

- **URL**: https://apify.com/maliksaid/europe-company-registers.md
- **Developed by:** [Malik Said](https://apify.com/maliksaid) (community)
- **Categories:** Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 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.
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

## European Company Registry: FR, CZ, PL, FI, EE

Get company registry data from five European countries in one schema. This Actor reads the official business registers of France, the Czech Republic, Poland, Finland and Estonia. Search companies by name, look them up by company number, or get newly registered companies every day.

Sales teams, KYB and onboarding teams, data vendors and researchers use it to check companies and find new B2B leads. Every row has the same fields, whatever the country.

### Company registers covered

| Country | Official register | Search by name | Lookup by ID | New companies |
|---|---|---|---|---|
| France | Sirene and RNE, through the Annuaire des Entreprises API | Yes | SIREN or SIRET | No |
| Czech Republic | ARES (Ministry of Finance) | Yes | IČO | No |
| Poland | KRS, National Court Register (Ministry of Justice) | No | KRS number | Yes |
| Finland | PRH YTJ open data | Yes | Business ID (Y-tunnus) | Yes |
| Estonia | e-Business Register open data (RIK) | Yes | Registry code | Yes |

New companies found in a full test run for 9 to 22 October 2026:

| Country | New companies returned | Left out (sole traders and partnerships) |
|---|---|---|
| Poland | 2,107 | 51 |
| Estonia | 899 | 90 |
| Finland | 860 | 5 |

The Estonian file is published once a day, so it runs one or two days behind.

The French and Czech APIs have no search by registration date. To find recent French or Czech companies, use search mode with a name and **Registered on or after**.

### Company data returned

| Field | Meaning |
|---|---|
| `country`, `countryName` | FR, CZ, PL, FI or EE |
| `registryId`, `registryIdType` | SIREN, IČO, KRS number, Business ID or registry code |
| `companyName` | Registered name |
| `legalFormCode`, `legalForm` | Legal form as the register writes it, for example 5710 (SAS), 112 (s.r.o.), OY or OÜ |
| `legalFormGroup` | One shared group: private limited company, public limited company, cooperative, nonprofit, public body, branch of foreign company or other |
| `status`, `statusText` | active, in liquidation, bankrupt, closed or other, plus the register's own text |
| `registrationDate`, `closedDate` | Date created or first registered, and date closed |
| `vatNumber` | Czech DIČ or Estonian KMKR VAT number |
| `taxId`, `statisticalId` | Polish NIP and REGON |
| `industryCode`, `industryCodes`, `industryCodeSystem`, `industryDescription` | NACE-based industry codes (NAF, CZ-NACE, PKD, TOL) |
| `street`, `postcode`, `city`, `region`, `addressCountryCode`, `fullAddress` | Registered address |
| `employeeRange` | Employee band (France) |
| `website` | Website, when registered (Finland, Poland) |
| `shareCapital`, `shareCapitalCurrency` | Share capital (Poland) |
| `sourceName`, `sourceUrl`, `apiUrl` | Register, licence and links to the record |

Sample record from a test run:

```json
{
  "id": "PL:0001274431",
  "country": "PL",
  "countryName": "Poland",
  "registryId": "0001274431",
  "registryIdType": "KRS",
  "companyName": "BABIK RENTAL SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "legalFormCode": "SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "legalForm": "SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "legalFormGroup": "private limited company",
  "status": "active",
  "statusText": "Aktywny",
  "registrationDate": "2026-10-22",
  "closedDate": null,
  "vatNumber": null,
  "taxId": "8971981140",
  "statisticalId": "546005492",
  "industryCode": "77.32.Z",
  "industryCodes": ["77.32.Z", "77.39", "77.34", "77.31", "77.1", "47", "46"],
  "industryCodeSystem": "PKD",
  "industryDescription": "WYNAJEM I DZIERŻAWA MASZYN I URZĄDZEŃ BUDOWLANYCH",
  "street": "UL. MARSZ. JÓZEFA PIŁSUDSKIEGO 74/320",
  "postcode": "50-020",
  "city": "WROCŁAW",
  "region": "DOLNOŚLĄSKIE",
  "addressCountryCode": "PL",
  "fullAddress": "UL. MARSZ. JÓZEFA PIŁSUDSKIEGO 74/320, 50-020 WROCŁAW",
  "employeeRange": null,
  "website": null,
  "shareCapital": 5000,
  "shareCapitalCurrency": "PLN",
  "sourceName": "National Court Register (KRS) open API, Ministry of Justice of Poland",
  "sourceUrl": "https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/0001274431?rejestr=P&format=json",
  "apiUrl": "https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/0001274431?rejestr=P&format=json",
  "scrapedAt": "2026-10-22T09:17:47.033Z"
}
```

Some fields are empty by design. Each register publishes different data:

- Industry codes: Estonia's open file has none. ARES lists Czech codes without marking a main one, so `industryCode` is empty there and `industryCodes` holds the list. Many new Finnish companies have no code yet.
- VAT numbers come only from the Czech and Estonian registers. Polish rows have NIP and REGON.
- Websites come only from Finland and Poland. Share capital comes only from Poland.

### How to use it

1. Pick a mode: **New companies**, **Search by name and filters**, or **Lookup by registry ID**.
2. Pick the countries.
3. Add filters if you need them: industry code prefixes, postcode prefixes, cities, legal form codes and dates.
4. For a daily lead feed, use new-company mode with **Monitor mode** on and schedule the Actor every day. Each run then returns only companies you have not received before.

Example inputs:

```json
{ "mode": "newCompanies", "countries": ["PL", "FI", "EE"], "daysBack": 3, "industryCodePrefixes": ["62"] }
```

```json
{ "mode": "search", "countries": ["FR", "CZ", "FI", "EE"], "searchText": "bakery", "cities": ["Paris", "Praha"] }
```

```json
{ "mode": "lookup", "registryIds": ["306138900", "CZ:00177041", "0000019193", "0112038-9", "EE:16752073"] }
```

### Input

| Option | Default | Meaning |
|---|---|---|
| Mode | New companies | New companies, search, or lookup |
| Countries | All five | FR, CZ, PL, FI, EE |
| Company name | None | Search mode. Every word must appear in the company name |
| Registry IDs | None | Lookup mode. SIREN or SIRET, IČO, KRS, Business ID or registry code. Add a prefix such as `CZ:` when an 8-digit ID could be Czech or Estonian |
| Days back | 3 | New-company mode. At most 14 days |
| Registered on or after / on or before | None | Date filters. In new-company mode they set the window |
| Industry code prefixes | None | For example `62` for software and IT, `41` for construction |
| Postcode prefixes | None | For example `75` for Paris or `00` for Helsinki |
| Cities | None | For example Paris, Praha, Warszawa, Helsinki, Tallinn |
| Legal form codes | All | Codes from the `legalFormCode` field |
| Active companies only | On | Leaves out closed, liquidating and bankrupt companies |
| Monitor mode | Off | Return only companies not returned before |
| Monitor state key | `default` | Name of the monitor memory |
| Maximum companies | 100 | Stop after this many companies. One run saves at most 10,000 |

Limits set by the registers:

- France returns at most 10,000 matches per search. Czech ARES returns at most 1,000; make the name more specific if it says so.
- Poland has no name search in its open API. Use lookup or new-company mode.
- Poland reads one record per new company. A 14-day window takes about 25 minutes.

### Pricing

The Actor uses pay-per-event pricing:

- $0.02 per run start (one event per GB of memory; the default 512 MB run counts as one).
- $0.002 per company saved to your dataset. That is $2 per 1,000 companies.

Companies skipped by your filters or by monitor mode cost nothing. Example: a daily Poland, Finland and Estonia run that returns 300 new companies costs about $0.62. Check the Pricing tab for the current price.

### Data sources, licences and privacy

- France: Annuaire des Entreprises API with INSEE Sirene and RNE data, Licence Ouverte 2.0.
- Czech Republic: ARES public API of the Ministry of Finance. The Actor stays well under the ARES request limits.
- Poland: KRS open API of the Ministry of Justice, provided under the Polish open data and re-use act.
- Finland: PRH YTJ open data, CC BY 4.0. Name PRH as the source when you use the data.
- Estonia: e-Business Register open data from RIK, CC BY 4.0.
- All sources are public and need no login. The Actor sends slow requests.

The Actor returns company data only:

- It never returns officers, directors, board members, shareholders, beneficial owners or any other named person. It never collects emails or phone numbers.
- Sole traders are always left out. So are general and limited partnerships, because their partners are private persons who are often named in the company name. There is no option to include them.
- Name search matches company names only. You cannot use it to find companies by a person's name.

### FAQ

#### Which company registry data can I get?

You get the registered name, ID, legal form, status, registration date, industry codes and registered address. Each register adds its own fields, such as VAT number, REGON or website.

#### Can I get new companies every day?

Yes, for Poland, Finland and Estonia. Run new-company mode daily with monitor mode on.

#### Does it include Germany or Belgium?

Not today. The Belgian open data needs an account, and the German register portal has usage limits.

#### Does it return directors or owners?

The Actor returns company data only. It leaves out every named person by design.

#### Can I send the results to my CRM?

Yes. Connect the dataset to Google Sheets, HubSpot, Make, Zapier or a webhook through Apify integrations.

### Related Actors

- [Norway & Finland New Companies](https://apify.com/maliksaid/nordic-new-companies): daily new companies from Brreg and PRH
- [UK Companies Register](https://apify.com/maliksaid/uk-companies-register): Companies House company data and new incorporations

### Support

Report a problem in the Issues tab. Include the run link.

# Actor input Schema

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

New companies: companies registered in the last days (Poland, Finland, Estonia). Search: find companies by name and filters (France, Czech Republic, Finland, Estonia). Lookup: get companies by registry ID (all five countries).

## `countries` (type: `array`):

Registers to read. FR = France (Sirene), CZ = Czech Republic (ARES), PL = Poland (KRS), FI = Finland (PRH YTJ), EE = Estonia (e-Business Register). Leave empty for all five.

## `searchText` (type: `string`):

Search mode. Every word must appear in the company name, for example "bakery" or "Nokia". Accents and case do not matter.

## `registryIds` (type: `array`):

Lookup mode. One ID per line: French SIREN (9 digits) or SIRET (14), Czech IČO (8), Polish KRS number (10), Finnish Business ID (1234567-8) or Estonian registry code (8). Add a country prefix such as CZ:12345678 when an ID could belong to two countries.

## `daysBack` (type: `integer`):

New-company mode. Companies registered in the last N days, today included. At most 14. Poland takes about one minute per day.

## `registeredFrom` (type: `string`):

Keep companies registered on or after this date (yyyy-mm-dd). In new-company mode it sets the start of the window instead of Days back.

## `registeredTo` (type: `string`):

Keep companies registered on or before this date (yyyy-mm-dd).

## `industryCodePrefixes` (type: `array`):

Keep companies with an industry code that starts with these digits. The registers use NACE-based codes, so 62 means software and IT in every country. Dots and letters are ignored. Estonia has no industry code in its open file, so this filter leaves Estonia out.

## `postcodePrefixes` (type: `array`):

Keep companies whose registered address postcode starts with one of these, for example 75 for Paris or 00 for Helsinki.

## `cities` (type: `array`):

Keep companies whose registered address is in one of these cities, for example Paris, Praha, Warszawa, Helsinki or Tallinn. Accents and case do not matter.

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

Keep only these legal forms, using the code in the legalFormCode field. Examples: 5710 (French SAS), 112 (Czech s.r.o.), SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ (Polish sp. z o.o.), OY (Finland), OÜ (Estonia).

## `activeOnly` (type: `boolean`):

Leave out companies that are closed, in liquidation or bankrupt. Lookup mode ignores this.

## `monitorMode` (type: `boolean`):

Return only companies that earlier monitor-mode runs with the same state key did not return. Schedule a daily new-company run with this on.

## `stateKey` (type: `string`):

Name of the memory that monitor mode uses. Use a different key for each separate watch list.

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

Stop after saving this many companies. One run saves at most 10,000. Set 0 to use that cap.

## Actor input object example

```json
{
  "mode": "newCompanies",
  "countries": [
    "FR",
    "CZ",
    "PL",
    "FI",
    "EE"
  ],
  "registryIds": [],
  "daysBack": 3,
  "industryCodePrefixes": [],
  "postcodePrefixes": [],
  "cities": [],
  "legalForms": [],
  "activeOnly": true,
  "monitorMode": false,
  "stateKey": "default",
  "maxItems": 100
}
```

# 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 = {
    "mode": "newCompanies",
    "countries": [
        "FR",
        "CZ",
        "PL",
        "FI",
        "EE"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maliksaid/europe-company-registers").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": "newCompanies",
    "countries": [
        "FR",
        "CZ",
        "PL",
        "FI",
        "EE",
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("maliksaid/europe-company-registers").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": "newCompanies",
  "countries": [
    "FR",
    "CZ",
    "PL",
    "FI",
    "EE"
  ],
  "maxItems": 100
}' |
apify call maliksaid/europe-company-registers --silent --output-dataset

```

## MCP server setup

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

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/ev1MnbrUqXmDGZ3tm/builds/jahDUgEvbQZ7O7LtD/openapi.json