# Poland New Companies (KRS daily registrations) (`delfielectronics/poland-new-companies`) Actor

Companies newly registered in the Polish KRS every day, from the official Open API KRS: NIP, REGON, address, capital, PKD. Filter by legal form, voivodeship, PKD. No persons.

- **URL**: https://apify.com/delfielectronics/poland-new-companies.md
- **Developed by:** [Artur Flamandzki](https://apify.com/delfielectronics) (community)
- **Categories:** Business, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Poland New Companies (KRS daily registrations)

Get the **companies newly registered in Poland every day** as clean JSON, straight from the official **Open API
KRS** of the Ministry of Justice (Krajowy Rejestr Sądowy). No API key, no login, no proxy and no browser. About
250-300 new entities join the KRS every working day: limited companies (sp. z o.o.), simple joint-stock
companies (P.S.A.), partnerships, cooperatives and foundations. Filter by **legal form, voivodeship and PKD
activity code**.

Every entity becomes one record: KRS number, name, legal form, **NIP and REGON**, registration date, registered
seat and address, website, **share capital**, main and other **PKD activities**, first financial year end, OPP
status, the bulletin days it appeared on and the link to its official extract.

### What you can use it for

- **New-company leads**: accounting offices, banks, insurers, office and IT suppliers reaching companies in their
  first days; run it daily with **Only entities not returned before** (on by default) to get each company once.
- **Market monitoring**: new IT companies (PKD 62) in Mazowieckie, new real-estate companies (PKD 68), etc.
- **KYC and CRM enrichment**: NIP, REGON and address of a new counterparty, via the Apify API or MCP.

### How it works

1. The actor reads the KRS daily bulletin of each day in your window (yesterday by default): the numbers of all
   entities with an entry that day (about 3,000 per working day).
2. In **new** mode it keeps only the numbers above the highest number of an earlier day (new entities get the next
   free numbers), so only about 300 extracts per day are read; in **changed** mode it reads every entity.
3. It reads the current extract of each entity and keeps it when it was **registered at most N days before the
   bulletin day** (new mode) and matches your filters.

### Input

| Field | What it does |
|---|---|
| Bulletin day from / to | KRS bulletin days (Polish time), at most 31; empty = yesterday |
| What to return | `new` = newly registered entities (default); `changed` = every entity with any KRS entry |
| Registered within N days | New mode: registered at most N days before the bulletin day (default 7) |
| Registers | P = businesses (default); S = associations and foundations |
| Legal forms | e.g. SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ, PROSTA SPÓŁKA AKCYJNA; empty = all |
| Voivodeships | e.g. `mazowieckie`, `slaskie` (case and Polish letters ignored) |
| PKD codes + Also match other activities | `62`, `62.1`, `62.10.B` or `6210B`; main activity by default |
| Only entities not returned before + Memory name | Daily feeds without repeats; one memory name per feed |
| Max companies | Stop after this many |

### Output example

```json
{
  "krs": "0001277076",
  "register": "P",
  "name": "SOK SOFTWARE STUDIO SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "legalForm": "SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "regon": "54611534100000",
  "nip": "8982339884",
  "registrationDate": "2026-11-04",
  "lastEntryNo": 4,
  "lastEntryDate": "2026-11-05",
  "extractAsOf": "2026-11-05",
  "seat": {"country": "POLSKA", "voivodeship": "DOLNOŚLĄSKIE", "county": "WROCŁAW", "municipality": "WROCŁAW",
           "town": "WROCŁAW"},
  "address": {"street": "UL. NORBERTA BARLICKIEGO", "houseNo": "18", "flatNo": "5", "town": "WROCŁAW",
              "postcode": "50-324", "postOffice": "WROCŁAW", "country": "POLSKA"},
  "website": null,
  "shareCapital": {"amount": 5000.0, "currency": "PLN"},
  "mainActivity": {"code": "62.10.B", "description": "POZOSTAŁA DZIAŁALNOŚĆ W ZAKRESIE PROGRAMOWANIA"},
  "otherActivities": [],
  "firstFinancialYearEnd": "2027-12-31",
  "isPublicBenefit": false,
  "bulletinDays": ["2026-11-04"],
  "sourceUrl": "https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/0001277076?rejestr=P&format=json",
  "source": "Krajowy Rejestr Sądowy, Open API KRS (Ministry of Justice of Poland)"
}
```

Texts are kept as the register publishes them (upper case). The run also writes a **SUMMARY** record to its
key-value store: days read, empty and failed, numbers, candidates, extracts read, entities not in the chosen
registers, unavailable extracts, invalid dates, matched and saved companies, and why the run stopped.

### Pricing

Pay per event, no subscription. The prices are on the **Pricing** tab; you are charged for two events:

| Event | When |
|---|---|
| Bulletin day (`bulletin-day`) | once per day of your window whose bulletin was read and lists at least one entity |
| Company (`company`) | once per company saved to the dataset |

- An empty bulletin day (weekend, holiday) and a day the API could not deliver are not charged; nor is an extract
  that could not be read, or an entity your filters drop.
- A run starts only when your remaining budget covers one bulletin day and one company; before every extract the
  actor checks that one more company fits, so it never saves a company your budget cannot pay.
- Every bulletin day of the window is read and charged before the first extract; **Max companies** limits the
  companies, not the days. A long window with a small limit still pays one bulletin day per non-empty day.
- If your budget runs out while the days are read, the companies of the days already paid for are still read
  (as far as the budget allows); later days are not read.
- The form starts with **Max companies** = 100 for a cheap first run; the API default is 1000.
- Set a maximum cost per run in Apify and the actor stops cleanly when it is reached.

### Data and privacy

Source: **Krajowy Rejestr Sądowy (National Court Register)**, Open API KRS published by the **Ministry of Justice
of Poland** (prs.ms.gov.pl) under the KRS act (art. 4b) and the open-data act (art. 24). The actor calls only the
public API, one request at a time with a pause between calls; it does not scrape any website.

The register is public by law, but an extract also names board members, proxies, shareholders and founders with
their PESEL numbers. The actor keeps **company data only** (name, legal form, identifiers, registered seat and
address, website, capital, activities): it reads **no persons, no PESEL and no e-mail addresses** (they often
name a person). A partnership's name can hold a surname: it is the official business name and is kept.

### Known limits

- The bulletin covers days from 2021-12-09; a new entity appears on 1-4 bulletin days (registration, then REGON
  and NIP entries), so NIP and REGON may still be empty on the first day: a daily run with memory returns the
  company once, on the first day it matches.
- New mode relies on new entities getting the next free KRS numbers; an entity registered under a much lower
  number would be missed (not seen in measurements).
- Today's bulletin is still growing: a run with **To** = today returns only the entries published so far.
- The memory of returned entities is saved during the run and at its end; after a hard crash or timeout a few
  companies may be returned again. Two runs at the same time with the same memory name do not share it: give
  parallel feeds different memory names.
- Legal forms are the ones KRS publishes; a form new to the actor is listed in the SUMMARY and cannot be selected
  until the actor is updated.

# Actor input Schema

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

First KRS bulletin day to read (YYYY-MM-DD, Polish time, from 2021-12-09). Empty = yesterday. A window holds at most 31 days.

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

Last KRS bulletin day to read (YYYY-MM-DD, not after today). Empty = yesterday.

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

new = entities registered in KRS at most 'Registered within N days' before the bulletin day they appear on; changed = every entity with any KRS entry on those days.

## `newWithinDays` (type: `integer`):

In 'new' mode: keep entities registered at most this many days before the bulletin day (0 = registered that day). New entities appear in the bulletin on 1-4 days after registration.

## `registers` (type: `array`):

P = register of businesses (companies, partnerships, cooperatives, foundations doing business); S = associations, foundations and other organisations. Both = P tried first.

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

Keep these legal forms (as KRS publishes them). Empty = all.

## `voivodeships` (type: `array`):

Registered seat voivodeship, e.g. mazowieckie, Śląskie or slaskie (case and Polish letters ignored). Empty = all of Poland.

## `pkdPrefixes` (type: `array`):

Activity codes (PKD 2025) or their start: 62, 62.1, 62.10, 62.10.B or 6210B. Matched on the main activity unless 'Also match other activities' is on. Empty = all.

## `pkdIncludeOther` (type: `boolean`):

Match 'PKD codes' on the other registered activities too, not only on the main one.

## `onlyNew` (type: `boolean`):

Return only entities this actor has not returned to you before under the same memory name and filters (memory kept 60 days). A new company is listed on several bulletin days, so keep this on for a daily feed.

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

Name of the 'Only entities not returned before' memory (1-50 letters, digits, - or \_). Use different names for separate feeds.

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

Stop after saving this many companies; no further extract is read or charged (the bulletin days of the window are read and charged first). The form starts at 100 for a cheap first run; the API default is 1000.

## Actor input object example

```json
{
  "mode": "new",
  "newWithinDays": 7,
  "registers": [
    "P"
  ],
  "legalForms": [],
  "voivodeships": [],
  "pkdPrefixes": [],
  "pkdIncludeOther": false,
  "onlyNew": true,
  "stateKey": "default",
  "maxItems": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

The run's companies in the Store table view.

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

Every field of every company record.

# 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 = {
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("delfielectronics/poland-new-companies").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 = { "maxItems": 100 }

# Run the Actor and wait for it to finish
run = client.actor("delfielectronics/poland-new-companies").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 '{
  "maxItems": 100
}' |
apify call delfielectronics/poland-new-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delfielectronics/poland-new-companies"
        }
    }
}
```

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/FRSxQ22BzPGeb30te/builds/MijfAofU9WZfhGo6V/openapi.json