# KRS Scraper - Polish Company Registry Data (`studio-amba/krs-scraper`) Actor

Extract company data from Poland's KRS (Krajowy Rejestr Sadowy). Get company name, KRS number, NIP, REGON, legal form, address, share capital, board members. Search by name, KRS number, or NIP. No login required.

- **URL**: https://apify.com/studio-amba/krs-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 10 total users, 4 monthly users, 97.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## KRS Scraper

Look up Polish companies in the KRS (Krajowy Rejestr Sadowy / National Court Register) by name, KRS number or NIP. Each company comes back as one row with name, KRS number, NIP, REGON, legal form, address, share capital, registration date and board members. A list of up to 2,000 KRS numbers or NIPs runs in one go, and the run reports which ones the register does not know. The data comes from the Ministry of Justice's open API, so no login or cookies are needed.

### How to scrape KRS data

1. Click **Try for free** on this page to open the actor in Apify Console.
2. Enter a company name (e.g., `PKP`), a 10-digit KRS number (e.g., `0000019193`), or a NIP tax number (e.g., `5250000251`).
3. For a name search, set the maximum number of results (default: 100).
4. Click **Start** and wait for the run to finish.
5. Download your data as JSON, CSV, Excel, or connect it to your workflow via the Apify API.

### Why use this actor?

Poland's KRS (Krajowy Rejestr Sadowy) is the official National Court Register maintained by the Ministry of Justice. It contains registration data for all Polish companies, foundations, and associations. This actor gives you programmatic access to that data without manual searches on the government portal.

Use cases:

- **Due diligence**: Verify company details, board composition, and share capital before business deals.
- **Lead generation**: Find companies by name or location for B2B outreach.
- **Compliance monitoring**: Track registration changes and company status.
- **Market research**: Analyze the Polish corporate landscape by legal form, capital, or region.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search companies by name (min 3 characters). The input form is prefilled with `PKP`. If you send no criteria at all through the API, the actor searches `warszawa`. |
| `krsNumber` | String | No | Look up a specific company by its 10-digit KRS number. |
| `nip` | String | No | Search by Polish tax identification number (NIP, 10 digits). |
| `krsNumbers` | Array | No | A list of KRS numbers to look up in one run. Up to 2,000 lookups per run, together with `nips`. |
| `nips` | Array | No | A list of NIPs to look up in one run. Up to 2,000 lookups per run, together with `krsNumbers`. |
| `maxResults` | Integer | No | Maximum results to return for a name search (default: 100, max: 1000). It does not apply to a list lookup. |
| `proxyConfiguration` | Object | No | Proxy settings. Polish residential proxies recommended. |

Provide one of `searchQuery`, `krsNumber`, or `nip`. If you give several, `krsNumber` is used first, then `nip`, then `searchQuery`. If you give none, the actor runs a name search for `warszawa`.

#### Example input

```json
{
    "searchQuery": "Allegro",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PL"
    }
}
```

#### Direct KRS number lookup

```json
{
    "krsNumber": "0000019193"
}
```

#### NIP lookup

```json
{
    "nip": "5250000251"
}
```

#### List lookup

Look up many companies in one run with `krsNumbers`, `nips`, or both. One run takes up to 2,000 lookups and runs 8 at a time. In a local test on 11 October 2026, 239 lookups finished in 97 seconds.

```json
{
    "krsNumbers": ["0000019193"],
    "nips": ["712-262-67-44"]
}
```

Every company found is one dataset row. The run also writes an `OUTPUT` record to its key-value store with the values that returned no row, grouped as `notFound` (not in the register), `struckOff` (no current extract), `invalid`, `failed` (the register did not answer) and `notProcessed` (the run reached its timeout first). You are charged for the rows only. When `krsNumbers` or `nips` is filled, the single `krsNumber`, `nip` and `searchQuery` fields and `maxResults` are ignored.

### Output

Each result contains the following fields. `nip`, `regon`, `shareCapital` and `boardMembers` are empty when the register has no entry for them: in a 10-company run, `nip` was filled on 8, `regon` on 7, `shareCapital` on 7 and `boardMembers` on 8.

| Field | Type | Example |
|-------|------|---------|
| `companyName` | String | `"POLSKIE KOLEJE PANSTWOWE SPOLKA AKCYJNA"` |
| `krsNumber` | String | `"0000019193"` |
| `nip` | String | `"5250000251"` |
| `regon` | String | `"00012680100000"` |
| `legalForm` | String | `"SPOLKA AKCYJNA"` |
| `registrationDate` | String | `"2001-06-11"` |
| `address` | String | `"ALEJE JEROZOLIMSKIE 142A"` |
| `city` | String | `"WARSZAWA"` |
| `postalCode` | String | `"02-305"` |
| `shareCapital` | Number | `10150715600.00` |
| `currency` | String | `"PLN"` |
| `status` | String | `"active"` |
| `boardMembers` | Array | `[{"name": "K******** C*******", "role": "PREZES ZARZADU"}]` |
| `url` | String | URL to the KRS detail page |
| `scrapedAt` | String | ISO timestamp |

#### Example output

```json
{
    "companyName": "POLSKIE KOLEJE PANSTWOWE SPOLKA AKCYJNA",
    "krsNumber": "0000019193",
    "nip": "5250000251",
    "regon": "00012680100000",
    "legalForm": "SPOLKA AKCYJNA",
    "registrationDate": "2001-06-11",
    "address": "ALEJE JEROZOLIMSKIE 142A",
    "city": "WARSZAWA",
    "postalCode": "02-305",
    "shareCapital": 10150715600.00,
    "currency": "PLN",
    "status": "active",
    "boardMembers": [
        { "name": "K******** C*******", "role": "PREZES ZARZADU" },
        { "name": "W****** P**********", "role": "CZLONEK ZARZADU - WICEPREZES" }
    ],
    "url": "https://wyszukiwarka-krs.ms.gov.pl/dane-szczegolowe-podmiotu?numerKRS=0000019193",
    "scrapedAt": "2026-10-15T04:01:03.808Z"
}
```

### Important notes

- **Personal data is anonymized**: The official KRS API anonymizes personal data (first letters of names and PESEL numbers) in compliance with Polish data protection regulations. Board member names appear partially masked in the output.
- **Data source**: This actor uses the official KRS Open API (api-krs.ms.gov.pl) maintained by the Polish Ministry of Justice. Data corresponds to current KRS extracts (odpis aktualny).
- **No login required**: All data comes from publicly available government endpoints. No account or authentication needed.
- **Rate limits**: The government API may impose rate limits. The actor retries a refused or unanswered request six times, the last two without the proxy. For many companies, use one list run (`krsNumbers` / `nips`) instead of one run per company.
- **Struck-off companies**: A company that has been struck off the register has no current extract and is not returned. A name search can therefore return fewer rows than the register shows matches. The run's status message gives the number skipped (50 of 150 matches for `PKP`, 5 of 15 for `Allegro`).
- **Status field**: Companies can be `active`, `in_liquidation`, or `deleted`. Most searches return active companies.

### Data coverage

The KRS register contains data for:

- **Spolki handlowe** (commercial companies): SA, sp. z o.o., sp.k., sp.j., sp.p., SKA
- **Stowarzyszenia** (associations) and **fundacje** (foundations)
- **Spoldzielnie** (cooperatives)
- All entities required to register with the National Court Register

Each record is built from the current extract (odpis aktualny): identifiers, address, share capital and management board.

### Integrations

Connect this actor with other tools in your stack:

- **Apify API**: Fetch results programmatically in any language.
- **Webhooks**: Get notified when a run completes.
- **Zapier / Make**: Automate workflows with KRS data.
- **Google Sheets**: Export directly to spreadsheets.
- **Slack / Email**: Send alerts when specific companies are found.

### Cost per result

Pricing is pay per event: $0.01 per GB of memory at start (the actor runs on 4 GB, so $0.04 per run) plus $0.012 per company row. Companies skipped as struck off are not charged.

| Run | Rows charged | Charged |
|-----|--------------|---------|
| One KRS number or NIP | 1 | $0.052 |
| Name search, 10 rows (`Allegro`) | 10 | $0.16 |
| Name search, 100 rows (`PKP`, default `maxResults`) | 98 | $1.22 |

The `PKP` run took 191 seconds. A name search makes one detail request per company, so 100 rows take about three minutes. A list run of up to 2,000 numbers pays the start fee once.

### Related scrapers

- [EU Dealer Counterparty Check](https://apify.com/studio-amba/eu-dealer-counterparty-check) runs this scraper alongside 14 other European registries and merges the results into one counterparty dossier with risk flags.

### Legal

This actor accesses publicly available data from the official KRS government portal (api-krs.ms.gov.pl). The data is published by the Polish Ministry of Justice under the Act on Open Data and the Re-use of Public Sector Information (August 11, 2021). Users are responsible for ensuring their use of the data complies with applicable laws.

# Actor input Schema

## `searchQuery` (type: `string`):

Search companies by name (e.g., 'PKP', 'Allegro', 'Orlen'). Minimum 3 characters. Defaults to 'warszawa' if no search criteria provided.

## `krsNumber` (type: `string`):

Look up a specific company by its 10-digit KRS number (e.g., '0000019193' for PKP). Returns a single detailed record.

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

Search by Polish tax identification number / NIP (e.g., '5250000251'). 10 digits, no dashes.

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

Look up many companies in one run. One KRS number per line. Up to 2,000 lookups per run (KRS numbers and NIPs together). When this list or the NIP list is filled, the single KRS Number, NIP and Company Name fields and Max Results are ignored. The run's OUTPUT record lists the numbers that are not in the register, struck off, invalid or failed.

## `nips` (type: `array`):

Look up many companies by NIP in one run. One NIP per line, with or without dashes. Up to 2,000 lookups per run (KRS numbers and NIPs together).

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

Maximum number of company records to return.

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

Apify proxy configuration. Polish proxies recommended for best reliability.

## Actor input object example

```json
{
  "searchQuery": "PKP",
  "krsNumber": "0000019193",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "PKP",
    "krsNumber": "0000019193",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "PL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/krs-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 = {
    "searchQuery": "PKP",
    "krsNumber": "0000019193",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/krs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "PKP",
  "krsNumber": "0000019193",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}' |
apify call studio-amba/krs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/krs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tuFxrN8lI9p9hnmqR/builds/UUhsDEYvQP4ZiE5B2/openapi.json