# Poland KRS Financial Scraper (`automation-lab/poland-krs-financial-scraper`) Actor

Extract official Polish KRS financial filing mentions by KRS number for compliance, credit-risk, accounting, and enrichment workflows.

- **URL**: https://apify.com/automation-lab/poland-krs-financial-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Financial Scraper

Extract public financial filing mentions from official Polish KRS current extracts by KRS number.

### What does Poland KRS Financial Scraper do?

Poland KRS Financial Scraper reads the official Polish National Court Register current-extract API and turns public financial document mentions into clean dataset rows.

It focuses on the `wzmianki o złożonych dokumentach` section that records annual financial statements, auditor opinions, approval resolutions, and management/activity reports.

### Who is it for?

- 🧾 Accounting firms checking whether Polish clients filed annual statements
- 🏦 Credit-risk analysts monitoring counterparties
- 🕵️ Compliance teams documenting public registry evidence
- 🔁 B2B enrichment teams adding KRS filing history to company records
- 📊 Data teams building periodic Polish company filing monitors

### Why use this actor?

- Uses the official public KRS JSON API
- Produces typed records instead of nested Polish registry JSON
- Keeps source URLs and raw filing snippets for audit trails
- Supports batches of KRS numbers
- Avoids private accounts and paid documents

### What data can I extract?

| Field | Description |
| --- | --- |
| `krsNumber` | Normalized 10-digit KRS number |
| `companyName` | Company name from the current KRS extract |
| `filingCategoryLabel` | Human-readable filing type |
| `reportingPeriod` | Period/year covered by the filing mention |
| `submittedAt` | Submission date when KRS exposes it |
| `latestEntrySignature` | Latest KRS/RDF case signature from the extract |
| `sourceApiUrl` | Official API URL used for the record |
| `rdfViewerUrl` | Public RDF viewer reference |
| `rawFiling` | Original filing mention object |

### How much does it cost to scrape Poland KRS financial filings?

The actor uses pay-per-event pricing: a small run start charge and a per-result charge for each saved filing mention.

Your total cost depends on how many KRS numbers you submit and how many filing mentions exist in their public current extracts.

### Input

Provide one or more Polish KRS numbers.

```json
{
  "krsNumbers": ["0000123456", "0000028860"],
  "maxItems": 100,
  "includeRawExtract": false,
  "requestDelayMs": 250
}
````

### Input fields

- `krsNumbers` — required list of KRS numbers, with or without leading zeroes
- `maxItems` — maximum records to save across the run
- `includeRawExtract` — attach the full raw official current extract to each item
- `requestDelayMs` — polite delay between KRS API requests

### Output

Each dataset row is one public financial-document mention.

```json
{
  "krsNumber": "0000123456",
  "companyName": "Example SP. Z O.O.",
  "filingCategoryLabel": "Annual financial statement filed",
  "reportingPeriod": "OD 01.01.2024 DO 31.12.2024",
  "submittedAt": "01.07.2025",
  "sourceApiUrl": "https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/0000123456?rejestr=P&format=json"
}
```

### How to run

1. Create a new Apify task.
2. Paste your KRS numbers into `krsNumbers`.
3. Set `maxItems` high enough for your batch.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for reliable batches

- Use normalized KRS numbers when possible.
- Keep `requestDelayMs` above zero for large monitoring lists.
- Turn on `includeRawExtract` only when you need full audit evidence.
- Use `maxItems` to control spend for first tests.

### Integrations

Use the dataset in:

- CRM enrichment workflows
- Credit-risk scoring pipelines
- Compliance evidence archives
- Accounting client dashboards
- Scheduled Apify tasks that monitor known KRS portfolios

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/poland-krs-financial-scraper').call({
  krsNumbers: ['0000123456'],
  maxItems: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/poland-krs-financial-scraper').call(run_input={
    'krsNumbers': ['0000123456'],
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~poland-krs-financial-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"krsNumbers":["0000123456"],"maxItems":50}'
```

### MCP for Claude

Connect Apify MCP with this actor:

`https://mcp.apify.com/?tools=automation-lab/poland-krs-financial-scraper`

Claude Code setup:

```bash
claude mcp add apify-krs-financial https://mcp.apify.com/?tools=automation-lab/poland-krs-financial-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-krs-financial": {
      "url": "https://mcp.apify.com/?tools=automation-lab/poland-krs-financial-scraper"
    }
  }
}
```

Example prompts:

- "Check these Polish KRS numbers for recent financial filing mentions."
- "Create a CSV of annual financial statement filing periods for this KRS list."
- "Compare which counterparties have filings covering 2024."

### Limitations

This actor extracts public filing mentions from official KRS current extracts. It does not bypass Imperva protection on the RDF browser and does not promise paid/private document contents.

When the official current extract exposes only a period without a submission date for a document type, the output keeps `submittedAt` as `null`.

### Legality

The actor accesses public registry data. You are responsible for using the data lawfully, respecting privacy rules, and following Apify terms and applicable Polish/EU law.

### FAQ

#### Can I search by company name?

This MVP accepts KRS numbers. Use your CRM, REGON, or another identifier source to resolve company names to KRS numbers first.

#### Does it download financial statement files?

No. It extracts public filing mentions from the official KRS current extract and links to the public RDF viewer for manual follow-up.

#### Why are some dates missing?

Some KRS filing mention categories expose a reporting period but not a submission date. The actor keeps the missing field as `null` instead of guessing.

#### What happens with invalid KRS numbers?

Invalid strings are ignored during normalization. Valid-looking numbers that the official API does not return are skipped with a warning.

### Related scrapers

- https://apify.com/automation-lab/polish-regon-scraper
- https://apify.com/automation-lab/crbr-beneficial-owners-scraper
- https://apify.com/automation-lab/krz-debtor-scraper

### Changelog

- Initial version: public KRS financial filing mention extraction by KRS number.

### Support

Open an Apify issue if you need additional fields, direct document download support, or company-name search support.

### Example monitoring workflow

Run this actor weekly with your KRS portfolio. Compare new dataset rows against your previous export by KRS number, filing type, and reporting period. Alert your team when a new annual statement period appears.

### Data quality notes

The actor preserves the official Polish reporting-period text because older records use several historical formats. Downstream systems can normalize these strings if they need a strict date range.

### Performance notes

The official JSON API is lightweight. Large batches are usually limited by polite request pacing rather than page rendering.

### Export options

Apify lets you export the dataset as JSON, JSONL, CSV, Excel, XML, RSS, or HTML. For BI tools, CSV and Excel are often easiest. For data pipelines, use JSONL or the dataset API.

# Actor input Schema

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

Polish KRS numbers to check. Values may include or omit leading zeroes and separators.

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

Maximum financial filing records to save across all KRS numbers.

## `includeRawExtract` (type: `boolean`):

Attach the full raw official KRS current-extract JSON to every output item. Useful for audits but increases dataset size.

## `requestDelayMs` (type: `integer`):

Polite delay between official API requests. Increase for large monitoring batches.

## Actor input object example

```json
{
  "krsNumbers": [
    "0000123456",
    "0000028860"
  ],
  "maxItems": 20,
  "includeRawExtract": false,
  "requestDelayMs": 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",
        "0000028860"
    ],
    "maxItems": 20,
    "includeRawExtract": false,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/poland-krs-financial-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",
        "0000028860",
    ],
    "maxItems": 20,
    "includeRawExtract": False,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/poland-krs-financial-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",
    "0000028860"
  ],
  "maxItems": 20,
  "includeRawExtract": false,
  "requestDelayMs": 250
}' |
apify call automation-lab/poland-krs-financial-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poland KRS Financial Scraper",
        "description": "Extract official Polish KRS financial filing mentions by KRS number for compliance, credit-risk, accounting, and enrichment workflows.",
        "version": "0.1",
        "x-build-id": "9McL2tiuwIPQQWX0a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~poland-krs-financial-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-poland-krs-financial-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/automation-lab~poland-krs-financial-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-poland-krs-financial-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/automation-lab~poland-krs-financial-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-poland-krs-financial-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",
                "required": [
                    "krsNumbers"
                ],
                "properties": {
                    "krsNumbers": {
                        "title": "KRS numbers",
                        "type": "array",
                        "description": "Polish KRS numbers to check. Values may include or omit leading zeroes and separators.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum filing records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum financial filing records to save across all KRS numbers.",
                        "default": 20
                    },
                    "includeRawExtract": {
                        "title": "Include raw KRS extract",
                        "type": "boolean",
                        "description": "Attach the full raw official KRS current-extract JSON to every output item. Useful for audits but increases dataset size.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between KRS requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between official API requests. Increase for large monitoring 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
