# Poland KRS Company Registry Scraper (`fetch_cat/poland-krs-company-registry-scraper`) Actor

Extract public Polish KRS company registry records by KRS number. Export names, IDs, addresses, representatives, activities, and capital.

- **URL**: https://apify.com/fetch\_cat/poland-krs-company-registry-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 krs record extracteds

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

## Poland KRS Company Registry Scraper

Extract public Polish KRS company registry records by KRS number. The actor accepts one or many KRS numbers and returns normalized company identity, address, registration, representative, shareholder/partner, business activity, and capital fields from the official public registry response.

### What you can do with it

- Enrich B2B lead lists with Polish company names, NIP, REGON, legal form, and address.
- Check compliance records for known KRS numbers in repeatable batches.
- Build market research datasets from official public registry extracts.
- Normalize pasted KRS numbers from spreadsheets into machine-readable JSON, CSV, or Excel exports.

### Who is it for?

Compliance teams, sales operations, B2B data vendors, researchers, and analysts who already have KRS numbers and need structured company registry exports without manually opening registry pages one by one.

### Input recipes

This example section can be pasted into the Apify Console input editor or sent through the API.

#### Look up two entrepreneurs-register companies

```json
{
  "krsNumbers": ["0000123456", "0000247804"],
  "register": "P",
  "maxConcurrency": 2,
  "delayMs": 250
}
````

#### Paste KRS numbers from a spreadsheet

```json
{
  "krsNumbersText": "123456\n247804",
  "register": "P",
  "includeRawOdpis": false
}
```

### Input

| Field | Type | Description |
| --- | --- | --- |
| `krsNumbers` | array of strings | KRS numbers to look up. Leading zeros are optional. |
| `krsNumbersText` | string | Optional pasted newline/comma/semicolon/space-separated KRS numbers. |
| `register` | string | `P` for entrepreneurs (default) or `S` for associations/foundations. |
| `includeRawOdpis` | boolean | Include the full raw official response for successful records. |
| `maxConcurrency` | integer | Parallel requests, 1-5. Default is 2. |
| `delayMs` | integer | Delay before each request. Default is 250 ms. |

### Output

Each dataset item represents one requested KRS number. Successful records have `status: "active"`; missing or failed records include `status` and `errorMessage`.

```json
{
  "krsNumber": "0000123456",
  "register": "P",
  "snapshotDate": "20.11.2025",
  "legalName": "RODENSTOCK POLSKA SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "legalForm": "SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "nip": "6342373405",
  "regon": "27676445600000",
  "address": {
    "country": "POLSKA",
    "voivodeship": "MAZOWIECKIE",
    "city": "WARSZAWA",
    "street": "AL. ALEJE JEROZOLIMSKIE",
    "houseNumber": "123A",
    "postalCode": "02-017"
  },
  "registrationDate": "25.07.2002",
  "lastEntryDate": "01.07.2025",
  "court": "SYSTEM",
  "status": "active",
  "representatives": [
    { "firstName": "V*****", "lastName": "N******", "function": "WICEPREZES ZARZĄDU SPÓŁKI" }
  ],
  "shareholdersOrPartners": [
    { "name": "RODENSTOCK BETEILIGUNGEN AUSLAND GMBH", "shares": "1200 UDZIAŁÓW O ŁĄCZNEJ WARTOŚCI 1.200.000 PLN" }
  ],
  "businessActivities": [
    { "code": "46.90.Z", "description": "SPRZEDAŻ HURTOWA NIEWYSPECJALIZOWANA", "isPrimary": true }
  ],
  "shareCapital": { "amount": "1200000,00", "currency": "PLN" },
  "sourceUrl": "https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/0000123456?rejestr=P&format=json",
  "scrapedAt": "2026-07-07T09:00:00.000Z"
}
```

### Output fields

`krsNumber`, `register`, `snapshotDate`, `legalName`, `legalForm`, `nip`, `regon`, `address`, `registrationDate`, `lastEntryDate`, `court`, `status`, `representatives`, `shareholdersOrPartners`, `businessActivities`, `shareCapital`, `rawOdpis` (optional), `sourceUrl`, `scrapedAt`, and `errorMessage` for failed lookups.

### Pricing

The actor uses pay-per-event pricing:

- Start: `$0.005` per run.
- KRS record extracted: `$0.000079009` per successful registry extract on the BRONZE tier, with standard Apify tier discounts for higher plans.

Missing or failed KRS numbers are saved with an error status but are not charged as successful extracts.

### API usage

Run the actor from the Apify API.

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~poland-krs-company-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"krsNumbers":["0000123456"],"register":"P"}'
```

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/poland-krs-company-registry-scraper').call({
  krsNumbers: ['0000123456'],
  register: 'P',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/poland-krs-company-registry-scraper').call(run_input={
    'krsNumbers': ['0000123456'],
    'register': 'P',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP / agent usage

Use this actor from AI agents through Apify MCP:

```text
https://mcp.apify.com/?tools=fetch_cat/poland-krs-company-registry-scraper
```

Add it to Claude Desktop or Claude Code:

```bash
claude mcp add apify-krs --url "https://mcp.apify.com/?tools=fetch_cat/poland-krs-company-registry-scraper"
```

Example MCP server JSON configuration:

```json
{
  "mcpServers": {
    "apify-krs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/poland-krs-company-registry-scraper"
    }
  }
}
```

Example prompts:

- "Look up KRS 0000123456 in the entrepreneurs register and summarize the company identity fields."
- "Extract KRS records for these numbers and return a CSV-ready table with KRS, name, NIP, REGON, address, and status."

### Legality

This actor extracts publicly available Polish KRS registry records for KRS numbers you provide. Use the data in line with applicable privacy, compliance, and database-use rules, especially when combining registry data with other personal or commercial datasets.

### Tips and limits

- Use the correct register: most companies are in `P`; associations and foundations are usually in `S`.
- Keep `maxConcurrency` low for large batches to avoid unnecessary pressure on the public registry service.
- KRS numbers are normalized to 10 digits automatically.
- Personal identifiers in the official response can be masked by the registry; the actor returns what is publicly provided.

### Related actors

- [CRBR Beneficial Owners Scraper](https://apify.com/fetch_cat/crbr-beneficial-owners-scraper) — collect Polish beneficial ownership data where available.
- [Email MX Deliverability Verifier](https://apify.com/fetch_cat/email-mx-deliverability-verifier) — validate company domains and mail infrastructure.
- [BuiltWith Domain Tech Stack Scraper](https://apify.com/fetch_cat/builtwith-domain-tech-stack-scraper) — enrich company domains with technology stack data.

### FAQ

#### Do I need a Polish registry account?

No. This actor is designed for public KRS registry extracts available without login.

#### Can I search by company name?

Not in version 1. This actor is optimized for exact KRS-number lookups.

#### What should I include in a support request?

Please include the run ID or run URL, your input JSON, expected output, and actual output. If a specific KRS number failed, include that number and the selected register.

### Support

If something looks wrong, open an issue on the actor page with the run ID/run URL, input JSON, expected output, and actual output so we can reproduce it quickly.

### Changelog

- Initial version: KRS-number lookup, normalized company fields, optional raw response, and batch input support.

# Actor input Schema

## `krsNumbers` (type: `array`):

Array of KRS numbers to look up. Leading zeros are optional; numbers are normalized to 10 digits.

## `krsNumbersText` (type: `string`):

Optional newline, comma, semicolon, or space separated KRS numbers. Useful for pasting from spreadsheets.

## `register` (type: `string`):

Official KRS register to query. P is the entrepreneurs register; S is the associations, foundations, and public health care institutions register.

## `includeRawOdpis` (type: `boolean`):

Adds the full official odpis JSON to each successful item. Leave off for smaller exports.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests to the official KRS API. Keep low for conservative registry usage.

## `delayMs` (type: `integer`):

Optional wait time before each request. Increase if you submit large batches.

## Actor input object example

```json
{
  "krsNumbers": [
    "0000123456",
    "0000247804"
  ],
  "register": "P",
  "includeRawOdpis": false,
  "maxConcurrency": 2,
  "delayMs": 250
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "krsNumbers": [
        "0000123456",
        "0000247804"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/poland-krs-company-registry-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 = { "krsNumbers": [
        "0000123456",
        "0000247804",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/poland-krs-company-registry-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 '{
  "krsNumbers": [
    "0000123456",
    "0000247804"
  ]
}' |
apify call fetch_cat/poland-krs-company-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poland KRS Company Registry Scraper",
        "description": "Extract public Polish KRS company registry records by KRS number. Export names, IDs, addresses, representatives, activities, and capital.",
        "version": "0.1",
        "x-build-id": "LcfRDIStcPWQMBVhT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~poland-krs-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-poland-krs-company-registry-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/fetch_cat~poland-krs-company-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-poland-krs-company-registry-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/fetch_cat~poland-krs-company-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-poland-krs-company-registry-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": {
                    "krsNumbers": {
                        "title": "KRS numbers",
                        "type": "array",
                        "description": "Array of KRS numbers to look up. Leading zeros are optional; numbers are normalized to 10 digits.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "krsNumbersText": {
                        "title": "KRS numbers as text",
                        "type": "string",
                        "description": "Optional newline, comma, semicolon, or space separated KRS numbers. Useful for pasting from spreadsheets."
                    },
                    "register": {
                        "title": "KRS register",
                        "enum": [
                            "P",
                            "S"
                        ],
                        "type": "string",
                        "description": "Official KRS register to query. P is the entrepreneurs register; S is the associations, foundations, and public health care institutions register.",
                        "default": "P"
                    },
                    "includeRawOdpis": {
                        "title": "Include raw KRS response",
                        "type": "boolean",
                        "description": "Adds the full official odpis JSON to each successful item. Leave off for smaller exports.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of parallel requests to the official KRS API. Keep low for conservative registry usage.",
                        "default": 2
                    },
                    "delayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional wait time before each request. Increase if you submit large batches.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
