# Poland CRBR Beneficial Owners Scraper (`skyline_scrapers/poland-crbr-scraper`) Actor

oland Beneficial Owners Scraper is an Apify Actor for extracting structured beneficial ownership data from Poland’s Central Register of Beneficial Owners, also known as CRBR or Centralny Rejestr Beneficjentów Rzeczywistych.

- **URL**: https://apify.com/skyline\_scrapers/poland-crbr-scraper.md
- **Developed by:** [Skyline Scrapers](https://apify.com/skyline_scrapers) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 1 total users, 1 monthly users, 36.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 queries

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🇵🇱 Poland Beneficial Owners Scraper

![Poland CRBR Scraper Banner](https://raw.githubusercontent.com/testerclark/assets/main/crbrbanner.png)

> Search Poland’s Central Register of Beneficial Owners (CRBR) by NIP, KRS, company name, or PESEL and export structured company, beneficial ownership, control, representative, address, discrepancy, and historical registry data.

***

## 🔍 What This Actor Does

**Poland Beneficial Owners Scraper** is an Apify Actor for extracting structured beneficial ownership data from Poland’s **Central Register of Beneficial Owners**, also known as **CRBR** or **Centralny Rejestr Beneficjentów Rzeczywistych**.

The Actor lets you search the Polish beneficial ownership register using:

- Polish tax identification number (**NIP**)
- National Court Register number (**KRS**)
- Company name
- Beneficial owner **PESEL**
- Multiple identifiers in one batch
- Historical date ranges

For every conclusive registry response, the Actor returns a clean, automation-ready record containing company information, registered address, beneficial owners, nature of control, representatives, registry periods, correction status, and discrepancy indicators.

It is useful for:

- AML and KYC research
- UBO verification
- Corporate due diligence
- Compliance screening
- Company ownership research
- Polish business intelligence
- Registry data enrichment
- Risk and fraud investigations
- Legal and financial research
- Automated company onboarding

***

## 🚀 How to Use

### 1. Choose a Search Method

Enter one of the following:

- A 10-digit Polish NIP
- A Polish KRS number
- A company name
- A PESEL number
- A batch of mixed searches

### 2. Configure Optional Settings

You can also choose:

- A historical start date
- A historical end date
- Official XML export
- Apify Proxy settings

### 3. Run the Actor

The Actor automatically:

- Creates a CRBR registry session
- Sends the selected registry query
- Retries temporary transport or anti-bot failures
- Normalizes Polish registry fields
- Resolves beneficial-owner control descriptions
- Preserves batch query order
- Separates registry results from transport errors
- Saves each company or historical period as a dataset item

### 4. Export the Results

Download or integrate the dataset as:

- JSON
- CSV
- Excel
- XML
- RSS
- Apify API output

***

## ⚙️ Features

- Search CRBR by NIP
- Search CRBR by KRS
- Search CRBR by company name
- Reverse lookup by PESEL
- Process multiple companies in one run
- Accept mixed batch query types
- Auto-detect bare NIP, KRS, and company-name strings
- Query current CRBR records
- Query historical registry periods
- Extract complete company names
- Extract Polish company identifiers
- Extract legal form
- Extract registered office address
- Extract beneficial owners
- Extract PESEL values returned by the registry
- Extract citizenship
- Extract country of residence
- Extract nature-of-control descriptions
- Extract nature-of-control codes
- Extract control-basis codes
- Extract company representatives
- Extract representative roles
- Detect reported discrepancies
- Count discrepancy records
- Detect corrected registry entries
- Return conclusive not-found records
- Preserve batch input order
- Store transport-level errors separately
- Save run statistics to the key-value store
- Export official CRBR XML files optionally
- API-ready structured output
- Apify Pay-per-Event compatible
- Optimized for automation workflows

***

## 💡 Example Tasks

#### Search CRBR by NIP

Find a Polish company by its tax identification number and extract its registered beneficial owners.

#### Search CRBR by KRS

Look up a company using its National Court Register number and retrieve ownership and representative data.

#### Search Polish Companies by Name

Use a company name or prefix to discover matching companies and their CRBR records.

#### Find Companies by Beneficial Owner

Use a PESEL reverse lookup to search for companies associated with a registered beneficial owner.

#### Verify Ultimate Beneficial Owners

Confirm the natural persons registered as beneficial owners of a Polish legal entity.

#### Build a Polish UBO Database

Collect structured company and beneficial ownership records for analysis or internal compliance systems.

#### Run Batch Company Checks

Submit many NIP, KRS, company-name, or PESEL searches in a single Actor run.

#### Perform AML Due Diligence

Use CRBR records as one data source in anti-money-laundering and customer due-diligence workflows.

#### Support KYC and KYB Checks

Enrich business verification workflows with official company identifiers, ownership data, and representatives.

#### Research Company Control Structures

Extract legal descriptions and codes explaining how each beneficial owner controls the company.

#### Check Historical Ownership Records

Use a date range to retrieve registry entries covering earlier ownership periods.

#### Detect CRBR Discrepancies

Identify records containing reported discrepancies and return the number of discrepancy entries.

#### Export Official Registry XML

Store the official XML representation of successful CRBR records in the run’s key-value store.

#### Enrich CRM or Compliance Records

Add NIP, KRS, legal form, company address, owners, and representatives to internal databases.

#### Automate Polish Company Research

Connect the Actor to Python, Node.js, Make, Zapier, Google Sheets, Airtable, or your own application.

***

## 🛠 Input Parameters

| Parameter | Type | Description |
|---|---|---|
| `nip` | String | Search one company by its 10-digit Polish tax identification number. |
| `krs` | String | Search one company by its National Court Register number. |
| `companyName` | String | Search by company name. Partial or prefix searches can return multiple companies. |
| `pesel` | String | Reverse lookup for companies associated with a beneficial owner’s PESEL. |
| `queries` | Array | Run multiple NIP, KRS, company-name, or PESEL searches in one batch. |
| `dateFrom` | String | Beginning of the requested registry period in `YYYY-MM-DD` format. |
| `dateTo` | String | End of the requested registry period in `YYYY-MM-DD` format. |
| `exportXml` | Boolean | Save the official CRBR XML export for successful records. |
| `proxyConfiguration` | Object | Configure Apify Proxy. Residential proxy usage is recommended for larger batches. |

At least one direct search field or one item in `queries` is required.

***

## 🧪 Input Examples

### Search by NIP

```json
{
  "nip": "6770065406",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Search by KRS

```json
{
  "krs": "0000057567"
}
```

### Search by Company Name

```json
{
  "companyName": "COMARCH"
}
```

### Search by PESEL

```json
{
  "pesel": "YOUR_PESEL_NUMBER"
}
```

### Mixed Batch Search

```json
{
  "queries": [
    { "nip": "6770065406" },
    { "krs": "0000057567" },
    { "companyName": "ORLEN" },
    "6770065406",
    "0000057567",
    "COMARCH"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Bare strings are automatically interpreted as:

- Exactly 10 digits: NIP
- Exactly 9 digits: KRS
- Other text: company name

### Historical Search with XML Export

```json
{
  "nip": "6770065406",
  "dateFrom": "2023-01-01",
  "dateTo": "2023-12-31",
  "exportXml": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

***

## 📤 Output Example

```json
{
  "requestId": "example-request-id",
  "name": "EXAMPLE COMPANY SP. Z O.O.",
  "nip": "6770065406",
  "krs": "0000057567",
  "legalForm": "SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "postalCode": "30-001",
  "voivodeship": "MAŁOPOLSKIE",
  "city": "KRAKÓW",
  "street": "PRZYKŁADOWA",
  "houseNumber": "10",
  "periodStart": "2024-01-01",
  "periodEnd": null,
  "corrected": false,
  "hasDiscrepancies": false,
  "discrepancyCount": 0,
  "proceeding": null,
  "found": true,
  "beneficialOwners": [
    {
      "firstName": "JAN",
      "lastName": "KOWALSKI",
      "pesel": "XXXXXXXXXXX",
      "citizenship": "POLSKA",
      "countryOfResidence": "POLSKA",
      "entitlements": [
        {
          "natureOfControl": "Registered nature of control returned by CRBR",
          "natureOfControlCode": "001",
          "controlBasisCode": 1
        }
      ]
    }
  ],
  "representatives": [
    {
      "firstName": "ANNA",
      "lastName": "NOWAK",
      "role": "Representative role returned by CRBR"
    }
  ],
  "sourceUrl": "https://crbr.podatki.gov.pl/"
}
```

A historical date range may create more than one dataset item for the same company when the registry returns multiple filing periods.

***

## 🧾 Extracted Fields

### Company Information

- `requestId`
- `name`
- `nip`
- `krs`
- `legalForm`
- `found`
- `sourceUrl`

### Registered Address

- `postalCode`
- `voivodeship`
- `city`
- `street`
- `houseNumber`

### Registry Period and Status

- `periodStart`
- `periodEnd`
- `corrected`
- `hasDiscrepancies`
- `discrepancyCount`
- `proceeding`

### Beneficial Owners

Each item in `beneficialOwners` can contain:

- `firstName`
- `lastName`
- `pesel`
- `citizenship`
- `countryOfResidence`
- `entitlements`

Each entitlement can contain:

- `natureOfControl`
- `natureOfControlCode`
- `controlBasisCode`

### Representatives

Each item in `representatives` can contain:

- `firstName`
- `lastName`
- `role`

***

## 📦 Dataset and Key-Value Store

### Default Dataset

The default dataset contains one structured item per company and registry period.

Conclusive `found: false` responses are also saved so your workflow can distinguish a genuine no-entry result from a network or anti-bot failure.

### Key-Value Store

The Actor can create the following records:

| Key | Description |
|---|---|
| `RUN_SUMMARY` | Number of total, successful, and failed queries. |
| `ERRORS` | Transport, proxy, blocked-request, or unexpected errors excluded from the main dataset. |
| `XML_<nip>` | Official XML export for a successful record when `exportXml` is enabled. |

***

## 👥 Who Uses This Actor

#### Compliance Teams

Verify beneficial owners and enrich AML, KYC, and KYB reviews with structured CRBR information.

#### Financial Institutions

Support corporate onboarding, ownership checks, customer risk reviews, and ongoing due diligence.

#### Law Firms

Research registered company ownership, control structures, representatives, and historical records.

#### Accountants and Auditors

Validate company identifiers and review beneficial ownership information during audits and engagements.

#### Corporate Intelligence Teams

Build searchable datasets of Polish companies, beneficial owners, addresses, and control relationships.

#### Investigators and Journalists

Research public corporate ownership records and connections between registered individuals and companies.

#### Developers and SaaS Platforms

Integrate CRBR data into compliance software, company databases, dashboards, and automated workflows.

#### Sales and Data Teams

Enrich Polish company records with official identifiers, legal form, address, and management information.

***

## ⭐ Why This Actor Is Different

- Multiple CRBR search modes in one Actor
- Supports NIP, KRS, company name, and PESEL
- Mixed batch queries with automatic string detection
- One dataset item per company or historical filing period
- Structured beneficial-owner entitlement data
- Human-readable nature-of-control descriptions
- Registry discrepancy detection
- Conclusive not-found results retained in the dataset
- Transport and proxy errors excluded from billable result records
- Optional official XML export
- Order-preserving batch processing
- Designed for API and compliance automation

***

## 🔌 API Integration

The Actor can be used through:

- Apify API
- Apify JavaScript client
- Apify Python client
- REST API calls
- Webhooks
- Make
- Zapier
- Google Sheets
- Airtable
- n8n
- CRM systems
- AML and KYC platforms
- Internal compliance applications

### API Input Example

```json
{
  "queries": [
    { "nip": "6770065406" },
    { "krs": "0000057567" }
  ],
  "exportXml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Use scheduled Actor runs to repeat company checks, refresh internal records, or monitor selected registry entries over time.

***

## 💳 Billing

This Actor is prepared for Apify **Pay per Event** pricing.

The code uses these event names:

| Event | When it is charged |
|---|---|
| `actor-start` | Once when the Actor run begins. |
| `record-found` | For each conclusive registry record added to the dataset. |

A conclusive `found: false` registry response is still a valid completed lookup. Transport failures, proxy failures, anti-bot failures, and unexpected request errors are stored separately and are not pushed as normal dataset records.

Actual event prices must be configured in the Actor’s **Monetization** settings in the Apify Console.

***

## ⚠️ Important Notes

- This Actor processes information returned by the public CRBR registry.
- CRBR availability, response formats, and anti-bot protections can change.
- Residential proxies are recommended for larger batches.
- Company-name searches can return multiple matching companies.
- Historical searches can return multiple records for one company.
- PESEL reverse-lookup availability and returned fields depend on the registry response.
- XML exports are saved in the key-value store, not inside dataset items.
- A record with `found: false` means the registry returned a conclusive no-entry result.
- Missing data can reflect an absent registry field rather than a scraper error.
- Users are responsible for complying with GDPR, Polish law, applicable data-protection rules, and the CRBR portal’s terms and permitted-use requirements.
- PESEL is personal data. Store, process, share, and retain it only when you have a lawful purpose and appropriate safeguards.
- This Actor does not provide legal, compliance, or financial advice.

***

## ❓ Frequently Asked Questions

### What is CRBR?

CRBR is the Polish Central Register of Beneficial Owners. The Polish name is **Centralny Rejestr Beneficjentów Rzeczywistych**.

### What is a beneficial owner?

A beneficial owner is a natural person identified in the registry as ultimately owning or controlling a legal entity through ownership, voting rights, other control rights, or another registered legal basis.

### Can I search by NIP?

Yes. Enter a 10-digit NIP in the `nip` field or include it in the `queries` array.

### Can I search by KRS?

Yes. Enter the company’s KRS number in the `krs` field or add it to a batch.

### Can I search by company name?

Yes. Company-name searches support partial or prefix matching and may return multiple records.

### Can I search by PESEL?

Yes. The Actor includes a PESEL reverse-lookup input for finding associated company records. Results depend on the registry response for that lookup mode.

### Can I process many companies together?

Yes. Use the `queries` array to submit mixed NIP, KRS, company-name, and PESEL searches.

### Can I retrieve historical records?

Yes. Set `dateFrom` and `dateTo` using `YYYY-MM-DD` values.

### Can I download official XML records?

Yes. Set `exportXml` to `true`. Successful XML exports are saved in the run’s key-value store.

### What happens when a company is not found?

The Actor saves a conclusive record with `found: false`. This is different from a failed request, which is written to the `ERRORS` key.

### Why should I use a proxy?

The registry uses anti-bot protection. Apify Proxy, particularly residential proxy access, can improve reliability for repeated or batch searches.

### Does the Actor expose raw internal API responses?

The public dataset contains normalized fields. Internal raw response data is removed before records are pushed to the dataset.

***

## 🌐 About Skyline Scrapers

Skyline Scrapers builds professional Apify Actors for:

- Company registry scraping
- Beneficial ownership research
- Business intelligence
- Real estate data extraction
- Lead generation
- Marketplace scraping
- CRM enrichment
- Compliance automation
- AI-ready datasets

**Skyline Scrapers — Smart Data Extraction for Modern Businesses**

# Actor input Schema

## `nip` (type: `string`):

Single-company search by Polish tax ID (NIP), 10 digits.

## `krs` (type: `string`):

Single-company search by National Court Register number (KRS).

## `companyName` (type: `string`):

Single search by company name. This is a partial/prefix match and can return multiple companies for one query.

## `pesel` (type: `string`):

Reverse lookup: find companies where this person (by PESEL) is a beneficial owner.

## `queries` (type: `array`):

Run multiple searches in one call. Each item can be a bare string (auto-detected as NIP/KRS/company name by digit pattern) or an object like {"nip": "..."}, {"krs": "..."}, {"companyName": "..."}, or {"pesel": "..."}. Also accepts the alias 'batchQueries'.

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

Start of the registry snapshot period (YYYY-MM-DD). Defaults to today (current entry only). CRBR coverage begins 2019-10-13.

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

End of the registry snapshot period (YYYY-MM-DD). Defaults to today.

## `exportXml` (type: `boolean`):

Also fetch the official CRBR XML export for each successful record and store it in the key-value store.

## `proxyConfiguration` (type: `object`):

Optional. Leave disabled to run without a proxy. For reliable CRBR lookups and higher success rates, Apify Residential Proxy (Poland) is recommended.

## Actor input object example

```json
{
  "nip": "8982201542",
  "queries": [],
  "exportXml": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}
```

# Actor output Schema

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

Structured company, beneficial-owner, representative, address, historical-period, and discrepancy data stored in the default dataset.

## `runSummary` (type: `string`):

Summary containing the total number of queries, successful queries, and failed queries.

## `errors` (type: `string`):

Transport-level or refused queries excluded from the billable dataset. This record is created only when at least one query fails.

## `xmlExports` (type: `string`):

Official CRBR XML exports generated when exportXml is enabled in the Actor input.

# 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 = {
    "nip": "8982201542"
};

// Run the Actor and wait for it to finish
const run = await client.actor("skyline_scrapers/poland-crbr-scraper").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 = { "nip": "8982201542" }

# Run the Actor and wait for it to finish
run = client.actor("skyline_scrapers/poland-crbr-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "nip": "8982201542"
}' |
apify call skyline_scrapers/poland-crbr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=skyline_scrapers/poland-crbr-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/crGHDxarUU3eZZS3u/builds/lwcMDWpWy4Cw9tMKt/openapi.json