# CEIDG sole proprietorships in Poland, jednoosobowa (`enterprising_hamster/polish-new-sole-proprietorships-ceidg`) Actor

New sole proprietorships in Poland from the official CEIDG registry, filtered by start date, PKD and voivodeship. Rows have NIP, REGON, status and address; no phone or email. Empty dates mean yesterday. Leave ceidgApiToken empty if the Actor has CEIDG_API_TOKEN; the run fails if both are empty.

- **URL**: https://apify.com/enterprising_hamster/polish-new-sole-proprietorships-ceidg.md
- **Developed by:** [Kamil Kaczmarek](https://apify.com/enterprising_hamster) (community)
- **Categories:** Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 76.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 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

## Poland New Sole Proprietorships API – CEIDG Feed

### For AI agents

This Actor returns one CEIDG row per sole proprietorship, with `name`, `nip`, `regon`, `status`, `startDate`, `address`, and PKD when the entry detail was read, and with no phone, email, or website. For sole proprietors who started in Poland yesterday, omit `dateFrom` and `dateTo` so the run uses yesterday in Europe/Warsaw, `events` `["started"]`, and `maxItems` 20. Add `"voivodeships": ["mazowieckie"]` for Mazovia, and set both dates for any other day. Leave `ceidgApiToken` empty only when `CEIDG_API_TOKEN` is already set on the Actor, because if both are empty the run fails before any request and charges nothing. `includeVatStatus` and `soleTraderFullAddress` default to false, so `statusVat` and the street stay null.

Poland sole proprietorships registered as JDG are the new businesses Poland records for Polish sole traders. This Actor reads the official CEIDG API and returns one row per entry. Filter by the day the activity started, by PKD, or by voivodeship.

You bring your own CEIDG JWT. The run fails before the first request when the token is missing, and it charges nothing for that failure. See [Privacy](#privacy).

### Use with AI agents (MCP)

Agents can call this Actor through the [Apify MCP server](https://mcp.apify.com). Add it as a single tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=enterprising_hamster/polish-new-sole-proprietorships-ceidg"
    }
  }
}
```

Questions an agent can answer with it:

- "Which sole traders started in Mazovia yesterday?" → `{"voivodeships": ["mazowieckie"], "maxItems": 20}`
- "New construction JDGs with PKD 41 since Monday." → `{"dateFrom": "2026-11-09", "dateTo": "2026-11-10", "pkd": ["41"], "events": ["started"]}`
- "Which CEIDG entries changed in the last five days?" → `{"dateFrom": "2026-11-05", "dateTo": "2026-11-09", "events": ["changed"], "maxItems": 50}`

Fields an agent gets: `name`, `nip`, `regon`, `status`, `startDate`, `address`, `pkdMain`, `otherPkd`, `sourceUrl`. There is no phone, email, or website.

Cost per result: $0.003 per company with `found` true, so the default 20 entries cost at most $0.06. Higher Apify plans pay less (down to $0.0024 per company). Pass `maxTotalChargeUsd` in the MCP `callOptions`. The run stops before that limit and still returns SUCCEEDED with the rows saved so far.

### What data you can get

`events` set to `started` (the default) calls `GET /firmy` with `dataod` and `datado` as the **activity start date**. The default statuses are `AKTYWNY` and `OCZEKUJE_NA_ROZPOCZECIE_DZIALANOSCI`. The list has no PKD. With `includePkd` true (the default) the Actor then calls `GET /firma/{id}` and keeps only the allow-listed fields, including PKD and the suspension, resumption, end, and deletion dates.

`events` set to `changed` calls `GET /zmiana`. That date is the **entry change date**, not the activity start date. The documentation recommends a window of at most five days, so a longer range is read in consecutive five-day windows, then each id is loaded with `/firma/{id}` and filtered by the same PKD and voivodeship rules. For `started`, a longer range is read in consecutive windows of at most 31 days. The inclusive span is at most 366 days, for example 2024-01-01 through 2024-12-31. If you select both events, `started` runs first and the same CEIDG id is charged once in the run.

Each saved row can include:

- **Identity:** CEIDG id, registered name, NIP, REGON, status, activity start date.
- **Place:** voivodeship, county, municipality, city, postal code, TERC, SIMC, ULIC. Street, building, and apartment only when `soleTraderFullAddress` is true.
- **Activity:** main PKD and other PKD codes, plus the PKD year, when the detail was read.
- **Provenance:** `source` is `CEIDG API v3`, `retrievedAt` is the read time, `sourceUrl` is the Hurtownia URL with no token.

### How to use

1. Set **CEIDG API token**, or set the Actor secret `CEIDG_API_TOKEN`. Press **Start**. With no other changes you get up to 20 entries whose activity started **yesterday**, Europe/Warsaw.
2. Pick **From date** and **To date**. The inclusive span can be at most 366 days, for example 2024-01-01 through 2024-12-31. Started reads use consecutive windows of at most 31 days. Changed reads stay in windows of 5 days. For `started`, those days are activity start dates. For `changed`, they are entry-change dates.
3. Leave **Events** on activity started, or switch to entry changed, or select both.
4. Narrow by **PKD codes** (`41`, `4120Z`) and **voivodeships** (`mazowieckie`).
5. Raise **Max entries** for a longer list. A daily schedule with empty dates returns yesterday's new entries. Set **Skip businesses already delivered** when a later run should not charge a NIP that an earlier run already saved.

You pay only for rows with `found` true. A row whose detail was missing is stored with `found` false and is not charged.

**What a month costs.** In the third quarter of 2026 Statistics Poland (GUS) recorded 61,729 newly registered natural persons conducting economic activity in the REGON register, on average 20,576 a month (21,247 in July, 19,113 in August, 21,369 in September). That is the official monthly count closest to new sole proprietorships; it counts REGON registrations in the calendar month, not CEIDG activity-start dates. At $0.003 per company (Apify FREE and BRONZE), a daily schedule with `events: ["started"]` and `maxItems` high enough for a busy day returns the whole of Poland for about $62 a month. One voivodeship costs less: Mazowieckie had 4,016 such registrations in September 2026 ($12.05). Construction (PKD 41–43) had 4,090 in September ($12.27). SILVER is $0.0027 and GOLD and higher $0.0024 per company, so the same all-Poland month is about $56 or $49. You pay only for businesses delivered, and you can cap the spend with Apify's cost limit.

### Input

| Field | Meaning |
| --- | --- |
| `dateFrom` / `dateTo` | Inclusive days (`YYYY-MM-DD`, Europe/Warsaw). Both empty means **yesterday**. At most **366** days, for example 2024-01-01 through 2024-12-31. Started reads use windows of at most 31 days; changed reads use 5 days. |
| `pkd` | PKD code or prefix. Dots are removed (`41.20.Z` becomes `4120Z`). |
| `voivodeships` | One or more of the 16 voivodeships, lowercase, as in the API. |
| `maxItems` | Stop after this many found entries (default **20**, max 20,000). |
| `events` | `started`, `changed`, or both. Default is `started` only. |
| `includePkd` | Read each listed entry for PKD and status dates. Default **true**. |
| `skipSeen` | Off by default. On, a NIP saved by an earlier run is not charged again. When the list already shows that NIP, the detail is not fetched. The memory keeps the 50,000 most recent NIP numbers. `maxItems` still counts only entries saved in the current run. |
| `includeVatStatus` | Ask the Ministry of Finance whitelist (WL2) for `statusVat` on today's date in Europe/Warsaw. Default **false**. |
| `soleTraderFullAddress` | Add street, building, and apartment. Default **false**. |
| `ceidgApiToken` | Hurtownia JWT, sent as Authorization Bearer. Leave it empty when `CEIDG_API_TOKEN` is set. A non-empty value is used instead. If both are empty, the run fails before any request and charges nothing. |

### Output

One item per CEIDG entry. Example with street hidden:

```json
{
  "id": "31F87519-9395-4FCF-8E19-6D5C0522FA7A",
  "name": "Piekarnia Testowa",
  "nip": "1112223344",
  "statusVat": null,
  "statusVatCode": null,
  "dataSprawdzenia": null,
  "regon": "123456789",
  "status": "AKTYWNY",
  "startDate": "2026-11-09",
  "suspensionDate": null,
  "resumptionDate": null,
  "endDate": null,
  "deletionDate": null,
  "pkdMain": {"code": "1071Z", "name": "Produkcja pieczywa"},
  "otherPkd": [{"code": "4724Z", "name": "Sprzedaz detaliczna pieczywa"}],
  "pkdYear": "2007",
  "address": {
    "voivodeship": "MAZOWIECKIE",
    "county": "Warszawa",
    "municipality": "Warszawa",
    "city": "Warszawa",
    "postalCode": "00-001",
    "terc": "1465011",
    "simc": "0918123",
    "ulic": "12345"
  },
  "source": "CEIDG API v3",
  "retrievedAt": "2026-11-10T12:00:00+00:00",
  "sourceUrl": "https://dane.biznes.gov.pl/api/ceidg/v3/firma/31F87519-9395-4FCF-8E19-6D5C0522FA7A",
  "environment": "production",
  "found": true,
  "error": null
}
```

The same example is in `examples/item.json`. With `includeVatStatus` left off, `statusVat`, `statusVatCode`, and `dataSprawdzenia` are null. Turn it on and a found NIP is checked with `GET /api2/status/nip/{nip}` on `https://wykazpodatnikowvat.mf.gov.pl`. `statusVat` is the label for the documented `statusCode`. C, Z, and N become `Czynny`, `Zwolniony`, and `Niezarejestrowany`. B, I, D, and X use the official description from the WL2 spec. An undocumented code becomes `unknown`, and `statusVatCode` holds the raw code. `dataSprawdzenia` is the ISO date we sent. A failed check leaves `statusVat` and `statusVatCode` null and still sets `dataSprawdzenia`. The call does not use the `search` method, so the row does not gain bank accounts or PESEL.

The table view **Entries** shows name, NIP, VAT, status, start date, city, voivodeship, and main PKD. The key-value record **SUMMARY** holds matched, saved, not found, duplicates, filtered, the cost-limit flag, and the window. **RUN_STATS** holds CEIDG request counts. WL2 calls are not in that counter.

### Pricing (pay per event)

| Event | Price | When |
| --- | --- | --- |
| `company` | $0.003 | One delivered entry with `found` true. |

No start fee and no separate charge per dataset row. Higher Apify plans pay less (down to $0.0024 per company). Set a maximum cost per run in Apify and the Actor stops before it with the rows saved so far. Platform usage is not added on top.

The price matches a CEIDG lookup that charges $0.003 per result and matches our REGON lookup. It is not higher than that lookup. The KRS company feed stays at $0.004 because it is a different register.

### Use cases

- **New JDG in a trade or voivodeship.** Each morning, list sole traders whose activity started yesterday in construction (`pkd: ["41"]`) or in Mazovia.
- **Next to the KRS feed.** KRS covers companies. This Actor covers natural persons who run a registered business.
- **AI agents.** Answer "who started a JDG in this PKD yesterday" through MCP.

This Actor does not return phone numbers, email addresses, or websites, so it is a poor fit for contact-lead lists.

### Privacy

CEIDG is a public register (art. 45 ust. 1 of the CEIDG act). From 1 November 2026, phone, email, and website are stored in CEIDG only with the entrepreneur's consent (art. 43 ust. 1 and 1a, Dz.U. 2026 poz. 507). This Actor does not treat that consent as consent to be contacted, and it does not return those fields.

Every entry is a natural person. The registered name often contains a first and last name. That string stays in `name`, because it is the registered business name. First name, last name, phone, email, website, electronic delivery address, other contact channels, marital property, date of death, citizenship, correspondence address, succession manager, receiver, and curator are not separate output fields. Street, building, and apartment are omitted unless `soleTraderFullAddress` is true.

The mapping is an allow-list. Tests run on documentation examples whose personal fields are replaced with markers (`tests/test_privacy.py`). The token is not written to the dataset, the key-value store, logs, or the error text.

The VAT check, when you turn it on, reads only the WL2 status for that NIP. The actor stores `statusVat`, `statusVatCode`, and `dataSprawdzenia`. It does not store the request id, bank accounts, or PESEL.

You decide the purpose of any later processing. The Actor records the source, the retrieval time, and that the row was processed (Open Data Act, art. 15 ust. 1).

The user who runs this Actor is the controller of any further use of a row, and that user has the duty to inform the person behind that sole proprietorship.

### Source and terms

- Data comes from **Ministerstwo Rozwoju i Technologii**, Hurtownia danych CEIDG i Biznes.gov.pl, API v3. Production base URL: `https://dane.biznes.gov.pl/api/ceidg/v3/`. Integrator note v1.1 is dated 14 January 2025.
- Each item has `retrievedAt` and `source` `CEIDG API v3`. SUMMARY repeats the source line and `"processed": true`.
- The ministry is not responsible for the result of this processing. Check the register before you rely on a row.

Documentation v1.1 also describes a test host. It does not publish a public test token. This Actor calls production with your token.

### API key

The call sends `Authorization: Bearer` plus your JWT. Pass it as the secret input `ceidgApiToken`, or set `CEIDG_API_TOKEN` on the Actor. Apply for the key in Biznes.gov.pl and dane.biznes.gov.pl with Profil Zaufany. The official PDF does not state how long the application takes.

The token is never copied into the dataset, SUMMARY, logs, or error messages.

### FAQ

**What is the difference between the two dates?** `started` filters by the day the activity started (`/firmy`, parameters `dataod` and `datado`). `changed` filters by the day the entry was updated (`/zmiana`). Those dates are not interchangeable.

**What are the API limits?** Both limits apply together. 50 requests per 3 minutes, and 1000 requests per 60 minutes. After the first limit the service pauses for 180 seconds from the last request, and a call during that pause moves the end. This Actor keeps at least 3.6 seconds between calls, retries network errors, HTTP 429, and HTTP 5xx, and does not send a call during the 180 second pause. At a steady 3.6 seconds the run stays on both limits (50 calls per 180 seconds, 1000 calls per hour).

**Does the list include PKD?** No. PKD, and the suspension, resumption, end, and deletion dates, come from `/firma/{id}`. Leave `includePkd` on unless you want the list fields only.

**Can I get phone, email, or the owner's name as separate fields?** No. The registered business name is in `name`. Contact fields are dropped.

**Can I get the VAT status?** Yes, with `includeVatStatus`. The source is the Ministry of Finance whitelist, method WL2, one call per found NIP, at least 0.25 seconds apart. You get `statusVat`, `statusVatCode`, and `dataSprawdzenia`. You do not get bank accounts or PESEL. The `company` price does not change. The run takes one extra HTTP call per saved entry. The published WL2 limit is 50,000 requests a day, and crossing a whitelist limit can block that IP until midnight. Leave the flag off for a large `maxItems` run unless you have measured the call count.

**What if the same firm appears twice in one run?** The id is charged once. Ids already in the default dataset are not charged again in that run.

**Can a daily schedule skip a NIP I already received?** Set `skipSeen` to true. The Actor then skips a 10-digit NIP it saved in an earlier run, up to the latest 50,000, and does not charge it. Leave `skipSeen` off to keep the current behavior. The key is the NIP, not the REGON, because a REGON can be 9 or 14 digits. An entry with no NIP is not stored in that memory.

**What if I hit the Apify cost limit?** The run stops, keeps the rows already saved, and ends SUCCEEDED.

### Integrations

Use the Apify API, scheduler, webhooks, Make, Zapier, n8n, or a Google Sheets export. A daily schedule with empty dates returns yesterday's new entries. Point an agent at `https://mcp.apify.com?tools=enterprising_hamster/polish-new-sole-proprietorships-ceidg`.

### Development

```bash
python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt
.venv/bin/python -m pytest
```

Tests run offline on fixtures taken from the v1.1 examples, with markers in personal fields. `tests/test_privacy.py` checks that those markers never reach the output, the logs, or SUMMARY, and that the token does not either. `pytest -m live_mf` with `VAT_LIVE=1` makes one call to the public WL2 API. Plain `pytest` skips that call. Do not put a token in the repo.

`scripts/gen_dataset_schema.py` writes `.actor/dataset_schema.json`. For a local run with simulated prices, set `ACTOR_TEST_PAY_PER_EVENT=true`, point `APIFY_ACTOR_PRICING_INFO` at `examples/pricing_info.local.json`, and delete `./storage` before `python3 -m src`.

### Disclaimer

Not affiliated with Ministerstwo Rozwoju i Technologii or CEIDG. The rows come from the Hurtownia API and are processed by this Actor.

### Po polsku

Aktor pobiera z API v3 Hurtowni danych CEIDG i Biznes.gov.pl nowe wpisy jednoosobowych działalności (JDG) oraz, osobnym trybem, wpisy zmienione w podanym oknie. Domyślnie `events` to `started`. Wtedy `dateFrom` i `dateTo` oznaczają datę rozpoczęcia działalności (`/firmy`, statusy `AKTYWNY` i `OCZEKUJE_NA_ROZPOCZECIE_DZIALANOSCI`). Tryb `changed` używa `/zmiana`, a to jest data zmiany wpisu, nie data startu. Zakres dłuższy niż 5 dni jest cięty na okna pięciodniowe. W trybie `started` zakres dłuższy niż 31 dni jest czytany w kolejnych oknach o szerokości co najwyżej 31 dni, a cały zakres łącznie obejmuje co najwyżej 366 dni. Lista `/firmy` nie zawiera PKD. Przy `includePkd` aktor dociąga `/firma/{id}` i zostawia tylko pola z allow-listy.

Opcjonalnie `skipSeen` pomija NIP zapisany we wcześniejszym runie i nie nalicza za niego opłaty. Domyślnie wyłączone. Kluczem jest NIP, nie REGON. Cena to 0,003 USD za wpis z `found` true. Brak opłaty startowej i brak osobnej opłaty za wiersz datasetu. Wyższe plany Apify płacą mniej, do 0,0024 USD. Limit kosztu zatrzymuje run przed progiem, ze statusem SUCCEEDED i z już zapisanymi wierszami. Ten sam identyfikator nie jest naliczany drugi raz w jednym runie.

Miesiąc nowych JDG z całej Polski (średnio 20 576 nowo zarejestrowanych osób fizycznych miesięcznie w III kwartale 2026 r. według GUS, rejestr REGON) to przy codziennym harmonogramie i cenie 0,003 USD około 62 USD. Mazowieckie we wrześniu 2026 r. to 4 016 wpisów (12,05 USD), budownictwo PKD 41–43 we wrześniu to 4 090 (12,27 USD). Płacisz tylko za dostarczone firmy i możesz ustawić limit kosztu.

Rejestr jest jawny (art. 45 ust. 1 ustawy o CEIDG). Od 1.11.2026 telefon, e-mail i strona www są w CEIDG tylko za zgodą przedsiębiorcy (art. 43 ust. 1 i 1a, Dz.U. 2026 poz. 507). Tej zgody nie traktujemy jako zgody na kontakt handlowy i tych pól nie oddajemy. Nazwa firmy zostaje w `name`, bo tak brzmi wpis. Ulica, budynek i lokal tylko przy `soleTraderFullAddress`. Opcja `includeVatStatus` dopytuje białą listę MF metodą WL2 i zapisuje `statusVat`, `statusVatCode` oraz `dataSprawdzenia`. Rachunku bankowego i PESEL nie pobiera. Cel dalszego przetwarzania określa użytkownik. Źródło, czas pobrania i informacja o przetworzeniu są w każdym wierszu i w SUMMARY (ustawa o otwartych danych, art. 15 ust. 1). Ministerstwo Rozwoju i Technologii nie odpowiada za rezultat tego przetworzenia.

Klucz JWT podajesz sam (`ceidgApiToken` albo sekret `CEIDG_API_TOKEN`). Wniosek składasz przez Biznes.gov.pl i dane.biznes.gov.pl, Profilem Zaufanym. Dokumentacja v1.1 z 14.01.2025 nie podaje czasu oczekiwania na klucz i nie publikuje publicznego klucza testowego. Limity API, oba naraz, to 50 żądań na 3 minuty i 1000 żądań na 60 minut. Aktor trzyma odstęp co najmniej 3,6 s i nie woła API w trakcie kary 180 s.

Aktor nie jest powiązany z MRiT ani z CEIDG.

# Changelog

This Actor's version history is a separate document: https://apify.com/enterprising_hamster/polish-new-sole-proprietorships-ceidg/changelog.md

# Actor input Schema

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

First day (YYYY-MM-DD, Europe/Warsaw). For events started this is the activity start date. For events changed this is the entry-change date. Empty with dateTo empty means yesterday. One day when only dateFrom is set.

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

Last day, inclusive, YYYY-MM-DD. When dateFrom is empty, this day alone is the range. When dateFrom is later than dateTo, the two days are swapped and the run continues. The inclusive range may be at most 366 days, for example 2024-01-01 through 2024-12-31. Started mode reads that range in consecutive windows of at most 31 days. Changed mode still reads it in windows of 5 days.

## `pkd` (type: `array`):

PKD codes or prefixes as the CEIDG filter expects them, for example 41 or 4120Z. Dots and spaces are removed. Empty means any activity.

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

Place of business must be in one of these voivodeships. Values match the API, for example mazowieckie. Empty means the whole country.

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

Stop after this many found entries are saved. Omitted means 20.

## `events` (type: `array`):

Default is started only. started filters /firmy by the activity start date. changed reads /zmiana by the entry-change date, then each entry. Both run started first, then changed, and the same id is charged once.

## `includePkd` (type: `boolean`):

For started, the /firmy list has no PKD. When this is true, each listed entry is read for PKD codes and for suspension, resumption, end, and deletion dates. Changed always reads each entry, whether this is true or false. The same field allow-list applies. Default true.

## `skipSeen` (type: `boolean`):

Skip a NIP that an earlier run of this Actor already saved. When the list already shows that NIP, the entry is not fetched again and is not charged. The default false does not skip. The memory keeps the 50,000 most recent NIP numbers. maxItems still counts only entries saved in the current run.

## `includeVatStatus` (type: `boolean`):

The row always has statusVat, statusVatCode, and dataSprawdzenia. They stay null when this is false. When this is true, each found entry with a 10-digit NIP is checked on today's date in Europe/Warsaw against the Ministry of Finance whitelist (WL2). Calls are at least 0.25 seconds apart. Bank accounts, PESEL, phone, and email are not requested. Default false.

## `soleTraderFullAddress` (type: `boolean`):

Default false. When false, the address has voivodeship, county, municipality, city, postal code and TERC/SIMC/ULIC only. Street, building and apartment are added only when this is true.

## `ceidgApiToken` (type: `string`):

Leave empty when the Actor has CEIDG_API_TOKEN. Otherwise paste a CEIDG Hurtownia JWT (Authorization Bearer). A non-empty value here is used instead of that environment variable, and surrounding spaces are removed. Blank text counts as empty. If this field and the environment variable are both empty, the run fails before any request and charges nothing.

## Actor input object example

```json
{
  "dateFrom": "2026-11-09",
  "dateTo": "2026-11-10",
  "pkd": [
    "41"
  ],
  "voivodeships": [
    "mazowieckie"
  ],
  "maxItems": 20,
  "events": [
    "started"
  ],
  "includePkd": true,
  "skipSeen": false,
  "includeVatStatus": false,
  "soleTraderFullAddress": false
}
```

# Actor output Schema

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

One dataset item per CEIDG entry. Keys written on every row: id, name, nip, statusVat, statusVatCode, dataSprawdzenia, regon, status, startDate, suspensionDate, resumptionDate, endDate, deletionDate, pkdMain, otherPkd, pkdYear, address, source, retrievedAt, sourceUrl, environment, found, error.

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

SUMMARY record keys: matched, saved, notFound, skippedDuplicate, skippedFilter, chargeLimitReached, partialDay, windowFrom, windowTo, events, source, processed.

## `stats` (type: `string`):

RUN_STATS record keys: requests, retries, failed_requests, items_pushed, items_skipped_seen, items_skipped_invalid_date, items_skipped_no_text, started_at, finished_at, duration_s.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("enterprising_hamster/polish-new-sole-proprietorships-ceidg").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("enterprising_hamster/polish-new-sole-proprietorships-ceidg").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 '{}' |
apify call enterprising_hamster/polish-new-sole-proprietorships-ceidg --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enterprising_hamster/polish-new-sole-proprietorships-ceidg"
        }
    }
}
```

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/VNTbWlAFPa3xJozHW/builds/NNEQ9543plmNqxaSg/openapi.json
