# Polish REGON Scraper - GUS Business Registry (no API key) (`regdata/polish-regon-scraper`) Actor

Scrape Poland's REGON (GUS) registry anonymously: look up by NIP/REGON/KRS, discover companies by address + PKD, and get local units (jednostki lokalne) as separate rows. No API key required.

- **URL**: https://apify.com/regdata/polish-regon-scraper.md
- **Developed by:** [regdata](https://apify.com/regdata) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Polish REGON Scraper - GUS Business Registry | Wyszukiwarka REGON (baza firm GUS)

Look up any Polish company in the official **REGON** registry (GUS) - by **NIP, REGON or KRS**, or discover every business at an **address** filtered by **PKD** industry code. Returns clean JSON with identifiers, legal form, ownership, full address, registration dates, PKD codes - and **local units (jednostki lokalne) as separate rows**. **No API key, no registration, no proxy** - unlike the official BIR web service, which requires you to register for a key tied to your identity.

### Quick Start

Click **Try it** and paste this input to look up a company by tax ID:

```json
{
  "searchMode": "nip",
  "identifiers": ["5260250995"]
}
````

Or discover every company at a location, filtered to manufacturers:

```json
{
  "searchMode": "byAddress",
  "voivodeship": "Łódzkie",
  "county": "Łódź",
  "municipality": "Łódź",
  "city": "Łódź",
  "pkdSections": ["C"],
  "maxResults": 200
}
```

### Sample Output

```json
{
  "regon": "000010205",
  "regon14": "00001020500190",
  "nip": "5260006841",
  "name": "BANK POLSKA KASA OPIEKI SPÓŁKA AKCYJNA - ODDZIAŁ W ŁODZI",
  "recordType": "LOCAL_UNIT",
  "parentRegon": "000010205",
  "legalForm": "spółka akcyjna",
  "ownershipForm": "Własność krajowych osób fizycznych",
  "pkdMain": { "code": "64.19.Z", "name": "Pozostałe pośrednictwo pieniężne" },
  "voivodeship": "ŁÓDZKIE",
  "county": "Łódź",
  "city": "Łódź",
  "postalCode": "90-001",
  "street": "ul. Piotrkowska",
  "buildingNumber": "12",
  "registrationDate": "1998-01-29",
  "activityStartDate": "1929-10-17",
  "website": "www.pekao.com.pl",
  "scrapeStatus": "full",
  "scrapedAt": "2026-05-26T08:00:00.000Z"
}
```

### Pricing

| Volume | Cost |
|--------|------|
| 1 result | $0.004 |
| 100 results | ~$0.40 |
| 1,000 results | ~$4.00 |
| 10,000 results | ~$40.00 |

Start cost per run: **$0** (only the synthetic Actor-start event at $0.00005). Free Apify credits ($5) = **~1,250 results** at no cost. No proxy required, so there are no proxy fees on top.

### Features

- **No API key, no registration** - works against the public REGON search anonymously; nothing tied to your identity
- **Local units (jednostki lokalne) as separate rows** - every physical branch with its own REGON and address, linked to the parent via `parentRegon` (not just the HQ)
- **Address + PKD discovery** - find all businesses in a voivodeship / county / municipality / city, narrowed by PKD industry section or code
- **Identifier lookup** - NIP, REGON or KRS, single or in bulk
- **Full official report** - legal form, ownership, registration dates, contact details, full address with TERYT codes
- **No browser, pure JSON** - fast and cheap; no proxy needed
- **Structured JSON output** - ready for CSV, Excel, API, or your CRM

### Related Actors

- [KRS Board Members & Shareholders Scraper](https://apify.com/regdata/krs-fullnames-scraper) - full non-anonymized director and shareholder names from KRS
- [KRS Financial Statements Scraper](https://apify.com/regdata/poland-krs-financial-scraper) - balance sheets and income statements from eKRS
- [KRZ Debtor Registry Scraper](https://apify.com/regdata/krz-debtor-scraper) - bankruptcy, restructuring and enforcement proceedings

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchMode` | string | No | `byAddress` | `byAddress`, `nip`, `regon`, or `krs` |
| `identifiers` | array | No | - | List of NIP / REGON / KRS numbers (identifier modes) |
| `voivodeship` | string | No | - | Region name (e.g. "Łódzkie") or TERYT code. Required for address search |
| `county` | string | No | - | Powiat name or TERYT code |
| `municipality` | string | No | - | Gmina name or TERYT code |
| `city` | string | No | - | Miejscowość name or TERYT code |
| `street` | string | No | - | Optional street name or code |
| `nameFragment` | string | No | - | Optional company-name filter for address search |
| `pkd` | string | No | - | Optional PKD code passed to the search |
| `pkdSections` | array | No | - | Keep only records in these PKD 2007 sections (A-U) |
| `pkdCodes` | array | No | - | Keep only records whose PKD starts with one of these |
| `pkdMatch` | string | No | `any` | `any` = any reported PKD; `main` = only the main PKD |
| `legalForms` | array | No | - | Keep only entities whose legal form contains a phrase |
| `fetchFullReport` | boolean | No | `true` | Fetch each entity's full REGON report |
| `fetchPkd` | boolean | No | `true` | Fetch PKD activity codes |
| `includeLocalUnits` | boolean | No | `true` | Include local units as separate rows |
| `maxResults` | integer | No | `0` | Max records (0 = unlimited) |
| `minIntervalMs` | integer | No | `350` | Politeness delay between requests |
| `proxyConfiguration` | object | No | - | Optional. Residential PL proxy for very large runs |

#### Search Modes

| Mode | Searches For | Required Input |
|------|-------------|----------------|
| `byAddress` | All entities and local units at a location | `voivodeship` (+ optional county/municipality/city/street, PKD filters) |
| `nip` | A company by tax ID (NIP) | `identifiers` |
| `regon` | A company or local unit by REGON | `identifiers` |
| `krs` | A company by court-register number (KRS) | `identifiers` |

### Output Fields

| Field | Description |
|-------|-------------|
| `regon` / `regon14` | 9-digit REGON / 14-digit REGON (local units) |
| `nip` | Polish Tax ID |
| `name` | Entity or local-unit name |
| `recordType` | `HQ` (legal entity) or `LOCAL_UNIT` (jednostka lokalna) |
| `parentRegon` | Parent company REGON for a local unit |
| `legalForm` / `legalFormDetail` | Basic and detailed legal form |
| `ownershipForm` | Ownership form (forma własności) |
| `voivodeship` / `county` / `municipality` / `city` | Address names |
| `postalCode` / `street` / `buildingNumber` / `unitNumber` | Address detail |
| `terytVoivodeship` / `terytCounty` / `terytMunicipality` | TERYT codes |
| `pkdMain` / `pkd` | Main PKD `{code, name}` and full PKD list |
| `registrationDate` / `establishedDate` / `activityStartDate` / `endedDate` | Dates |
| `phone` / `email` / `website` | Contact details where published |
| `localUnitsCount` / `activitiesCount` | Counts from the report |
| `scrapeStatus` / `scrapedAt` | Per-record status and timestamp |

### Use Cases

- **B2B Lead Generation** - build targeted company lists by region and industry (PKD)
- **KYB / Company Verification** - confirm a company's identity, legal form and status by NIP/REGON/KRS
- **CRM & Data Enrichment** - enrich your records with official identifiers, address and PKD codes
- **Market Mapping** - map business density and industry distribution across a region
- **Site-level Prospecting** - reach physical branches (jednostki lokalne), not just headquarters
- **Bulk Processing** - validate and enrich thousands of NIP/REGON/KRS numbers at once

### Data Source & Compliance

- **Portal**: https://wyszukiwarkaregon.stat.gov.pl/
- **Operator**: Główny Urząd Statystyczny (GUS, Statistics Poland)
- **Register**: REGON - Krajowy Rejestr Urzędowy Podmiotów Gospodarki Narodowej
- **Coverage**: All registered Polish entities, sole traders and their local units
- **Access**: public registry data; the Actor reads only what GUS publishes openly
- **Data currency**: the GUS data-status date is reported in each run log

### Polish Business Data Suite

This Actor is part of the **Polish Business Data Suite** - 8 active actors covering the full Polish company intelligence stack. No subscriptions, no minimum commitment - pay only for what you use.

| Registry | Actor | What it does |
|----------|-------|-------------|
| **REGON** | Polish REGON Scraper (this actor) | Company identity, address, PKD, local units |
| **eKRS** | [Financial Statements](https://apify.com/regdata/poland-krs-financial-scraper) | Balance sheets, income statements |
| **KRS** | [Board Members](https://apify.com/regdata/krs-fullnames-scraper) | Full non-anonymized director names |
| **KRZ** | [Debtor Registry](https://apify.com/regdata/krz-debtor-scraper) | Bankruptcy, restructuring, enforcement |
| **KNF** | [Financial Supervision](https://apify.com/regdata/knf-registry-scraper) | 75,000+ regulated financial entities |
| **MSiG** | [Court Gazette](https://apify.com/regdata/msig-scraper) | Court announcements since 2001 |
| **CRBR** | [Beneficial Owners](https://apify.com/regdata/crbr-beneficial-owners-scraper) | UBO verification by NIP/KRS |
| **UOKiK** | [Abusive Clauses](https://apify.com/regdata/uokik-clauses-scraper) | 7,500+ banned contract clauses |
| **BDO** | [Waste Registry](https://apify.com/regdata/bdo-waste-registry-scraper) | 674,000+ waste management entities |

> **Full suite**: [apify.com/regdata](https://apify.com/regdata)

A typical KYB / due-diligence pipeline: identify the company here (REGON), pull its **financials** from eKRS, check its **directors** in KRS, screen it for **insolvency** in KRZ, and verify its **beneficial owners** in CRBR.

### Informacje po polsku

#### Czym jest ten aktor?

Ten aktor to **wyszukiwarka REGON** - automatyczny dostep do oficjalnej **bazy firm GUS** (Glowny Urzad Statystyczny). Pozwala sprawdzic dowolny podmiot po **NIP, REGON lub KRS**, albo wyszukac wszystkie firmy pod danym adresem z filtrem branzy (**PKD**). W przeciwienstwie do uslugi BIR, **nie wymaga klucza ani rejestracji** - nie musisz podawac swoich danych ani czekac na klucz uzytkownika.

#### Co wyroznia ten aktor?

Jako jeden z nielicznych zwraca **jednostki lokalne** jako osobne wiersze - kazdy oddzial i zaklad firmy z wlasnym numerem REGON i adresem, powiazany z firma macierzysta przez `parentRegon`. To realny widok "jeden wiersz na lokalizacje", a nie tylko siedziba.

#### Dla kogo?

Narzedzie sluzy do **generowania leadow B2B**, **weryfikacji kontrahenta (KYB)**, **wzbogacania danych w CRM** oraz **analizy rynku** - budowania list firm wedlug regionu i branzy. Dane zwracane sa jako ustrukturyzowany JSON gotowy do CSV, Excela lub integracji przez API.

#### Jak zaczac?

Uruchom aktora na platformie Apify, podajac NIP/REGON/KRS lub region i kod PKD. Mozesz tez zintegrowac go ze swoim systemem przez Apify API. Placisz wylacznie za faktyczne wyniki - bez abonamentu, bez proxy, bez minimalnych oplat.

### Limitations

- Address search and PKD search are separate on the source portal, so PKD filtering is applied per record (enable `fetchPkd`)
- Very large regions (tens of thousands of entities) should set `maxResults` and may use a residential PL proxy to avoid the portal's conditional rate limit
- Employment figures are confidential in REGON and are not returned (for per-site headcount, see the site-level prospecting tool)
- The source portal caps a single search at 16,000 records

***

### Wyszukiwarka REGON - baza firm GUS przez API

Automatyczny dostep do rejestru REGON prowadzonego przez GUS: dane firm po NIP, REGON i KRS, wyszukiwanie po adresie i kodzie PKD, jednostki lokalne jako osobne wiersze. Bez klucza API, bez rejestracji, bez proxy. Idealne do generowania leadow, weryfikacji kontrahentow (KYB) i wzbogacania danych. Rozliczenie wylacznie za uzycie.

# Actor input Schema

## `searchMode` (type: `string`):

How to search: discover all entities at an address (with optional PKD), or look up specific NIP / REGON / KRS numbers.

## `identifiers` (type: `array`):

List of identifiers to look up. Only used when search mode is nip / regon / krs.

## `voivodeship` (type: `string`):

Region name (e.g. "Łódzkie") or TERYT code. Required for address search. Diacritics optional.

## `county` (type: `string`):

County name or TERYT code within the voivodeship.

## `municipality` (type: `string`):

Municipality name or TERYT code within the county.

## `city` (type: `string`):

City/town name or TERYT code within the municipality.

## `street` (type: `string`):

Optional street name or code to narrow the address search.

## `nameFragment` (type: `string`):

Optional company-name fragment filter for address search.

## `pkd` (type: `string`):

Optional PKD activity code to filter the address search server-side (e.g. "62.01.Z").

## `pkdSections` (type: `array`):

Keep only records with a PKD code in these PKD 2007 sections. C=Manufacturing, G=Trade, H=Transport, etc. Requires fetchPkd.

## `pkdCodes` (type: `array`):

Keep only records whose PKD code starts with one of these (e.g. "10", "62.01"). Requires fetchPkd.

## `pkdMatch` (type: `string`):

'main' = only the main (przeważająca) PKD must match; 'any' = any reported PKD may match.

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

Keep only entities whose legal form contains one of these phrases (e.g. "spółka z ograniczoną", "spółka akcyjna").

## `fetchFullReport` (type: `boolean`):

Fetch each entity's full REGON report (legal form, ownership, dates, contact, full address). Adds one request per record.

## `fetchPkd` (type: `boolean`):

Additionally fetch each entity's PKD activity codes (main + secondary).

## `includeLocalUnits` (type: `boolean`):

Include local units as separate rows (recordType=LOCAL\_UNIT, with parentRegon). Address search returns these natively; identifier search expands them.

## `maxResults` (type: `integer`):

Maximum records to emit (0 = unlimited). Bounds cost on large regions.

## `minIntervalMs` (type: `integer`):

Politeness delay between requests. The site allows ~3/s; keep >= 350ms to avoid the conditional CAPTCHA.

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

Proxy settings. Residential PL proxies recommended for large/volume runs to avoid the conditional CAPTCHA.

## Actor input object example

```json
{
  "searchMode": "byAddress",
  "identifiers": [
    "5260250995"
  ],
  "voivodeship": "Łódzkie",
  "county": "kutnowski",
  "municipality": "Kutno",
  "city": "Kutno",
  "pkdMatch": "any",
  "fetchFullReport": true,
  "fetchPkd": true,
  "includeLocalUnits": true,
  "maxResults": 25,
  "minIntervalMs": 350,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

REGON records stored in the default dataset. See the dataset schema for the full field list and the 'overview' table view.

# 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 = {
    "identifiers": [
        "5260250995"
    ],
    "voivodeship": "Łódzkie",
    "county": "kutnowski",
    "municipality": "Kutno",
    "city": "Kutno",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("regdata/polish-regon-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 = {
    "identifiers": ["5260250995"],
    "voivodeship": "Łódzkie",
    "county": "kutnowski",
    "municipality": "Kutno",
    "city": "Kutno",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("regdata/polish-regon-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 '{
  "identifiers": [
    "5260250995"
  ],
  "voivodeship": "Łódzkie",
  "county": "kutnowski",
  "municipality": "Kutno",
  "city": "Kutno",
  "maxResults": 25
}' |
apify call regdata/polish-regon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polish REGON Scraper - GUS Business Registry (no API key)",
        "description": "Scrape Poland's REGON (GUS) registry anonymously: look up by NIP/REGON/KRS, discover companies by address + PKD, and get local units (jednostki lokalne) as separate rows. No API key required.",
        "version": "1.0",
        "x-build-id": "LPDzCfJLJzIoxg9YL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/regdata~polish-regon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-regdata-polish-regon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/regdata~polish-regon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-regdata-polish-regon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/regdata~polish-regon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-regdata-polish-regon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "byAddress",
                            "nip",
                            "regon",
                            "krs"
                        ],
                        "type": "string",
                        "description": "How to search: discover all entities at an address (with optional PKD), or look up specific NIP / REGON / KRS numbers.",
                        "default": "byAddress"
                    },
                    "identifiers": {
                        "title": "Identifiers (NIP / REGON / KRS)",
                        "type": "array",
                        "description": "List of identifiers to look up. Only used when search mode is nip / regon / krs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "voivodeship": {
                        "title": "Województwo (voivodeship)",
                        "type": "string",
                        "description": "Region name (e.g. \"Łódzkie\") or TERYT code. Required for address search. Diacritics optional."
                    },
                    "county": {
                        "title": "Powiat (county)",
                        "type": "string",
                        "description": "County name or TERYT code within the voivodeship."
                    },
                    "municipality": {
                        "title": "Gmina (municipality)",
                        "type": "string",
                        "description": "Municipality name or TERYT code within the county."
                    },
                    "city": {
                        "title": "Miejscowość (city)",
                        "type": "string",
                        "description": "City/town name or TERYT code within the municipality."
                    },
                    "street": {
                        "title": "Ulica (street, optional)",
                        "type": "string",
                        "description": "Optional street name or code to narrow the address search."
                    },
                    "nameFragment": {
                        "title": "Name fragment (optional)",
                        "type": "string",
                        "description": "Optional company-name fragment filter for address search."
                    },
                    "pkd": {
                        "title": "PKD code (optional)",
                        "type": "string",
                        "description": "Optional PKD activity code to filter the address search server-side (e.g. \"62.01.Z\")."
                    },
                    "pkdSections": {
                        "title": "Filter - PKD sections (A-U)",
                        "type": "array",
                        "description": "Keep only records with a PKD code in these PKD 2007 sections. C=Manufacturing, G=Trade, H=Transport, etc. Requires fetchPkd.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pkdCodes": {
                        "title": "Filter - PKD code prefixes",
                        "type": "array",
                        "description": "Keep only records whose PKD code starts with one of these (e.g. \"10\", \"62.01\"). Requires fetchPkd.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pkdMatch": {
                        "title": "PKD match mode",
                        "enum": [
                            "any",
                            "main"
                        ],
                        "type": "string",
                        "description": "'main' = only the main (przeważająca) PKD must match; 'any' = any reported PKD may match.",
                        "default": "any"
                    },
                    "legalForms": {
                        "title": "Filter - legal form",
                        "type": "array",
                        "description": "Keep only entities whose legal form contains one of these phrases (e.g. \"spółka z ograniczoną\", \"spółka akcyjna\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchFullReport": {
                        "title": "Fetch full report",
                        "type": "boolean",
                        "description": "Fetch each entity's full REGON report (legal form, ownership, dates, contact, full address). Adds one request per record.",
                        "default": true
                    },
                    "fetchPkd": {
                        "title": "Fetch PKD codes",
                        "type": "boolean",
                        "description": "Additionally fetch each entity's PKD activity codes (main + secondary).",
                        "default": true
                    },
                    "includeLocalUnits": {
                        "title": "Include local units (jednostki lokalne)",
                        "type": "boolean",
                        "description": "Include local units as separate rows (recordType=LOCAL_UNIT, with parentRegon). Address search returns these natively; identifier search expands them.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to emit (0 = unlimited). Bounds cost on large regions.",
                        "default": 0
                    },
                    "minIntervalMs": {
                        "title": "Min interval between requests (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Politeness delay between requests. The site allows ~3/s; keep >= 350ms to avoid the conditional CAPTCHA.",
                        "default": 350
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential PL proxies recommended for large/volume runs to avoid the conditional CAPTCHA.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
