# Slovak Company Registry (RPO) API → Clean JSON (`quietpinelabs/sk-rpo-company`) Actor

Company profiles from the official Slovak RPO register API (Register právnických osôb): IČO lookup or name search → normalised JSON with legal form, status, address, SK NACE, ORSR number, statutory bodies, history. CC BY 4.0 source, no scraping.

- **URL**: https://apify.com/quietpinelabs/sk-rpo-company.md
- **Developed by:** [Quietpine Labs](https://apify.com/quietpinelabs) (community)
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 company records

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/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

## Slovak company data from RPO as clean JSON — by IČO or name

Look up Slovak companies, public bodies and other registered entities in the **Register právnických osôb, podnikateľov a orgánov verejnej moci (RPO)**, the Slovak Republic's statutory master register, and get one normalised JSON record per entity: identifiers, legal form, status, registered address, SK NACE, ESA 2010 sector, Obchodný register entry, statutory bodies (names and roles only), signing rules, share capital and optional history. The actor uses the official RPO REST API only (no scraping, no API key, no proxies), keeps the register's own CC BY 4.0 licence notice in every record and withholds natural-person data by default.

### Who uses it

- **KYC/AML and credit analysts** — confirm an IČO, legal form, status and ORSR number, and see who may sign for the company.
- **Procurement, sales and finance ops** — enrich Slovak supplier or customer lists and keep them current with incremental mode; works from Make, Zapier or n8n without code.
- **Data journalists and researchers** — pull every entity whose current or former name matches a term, with establishment and termination dates.

### Use cases

**1. Enrich a list of IČO:**

```json
{ "icos": ["35763469", "00151742", "46450238"] }
```

One record per RPO entity found (a company and its registered branches can share one IČO — each is returned).

**2. Name search restricted to a region and period, with history:**

```json
{ "name": "Telekom", "region": "Bratislava", "dateFrom": "2000-01-01", "includeHistory": true, "maxRecords": 100 }
```

Legal persons whose current or historical name contains "Telekom", seated in Bratislava, established or terminated since 2000, with previous names and addresses.

**3. Watch a portfolio for changes (schedule daily):**

```json
{ "icos": ["35763469", "00151742"], "mode": "incremental" }
```

Only entities whose register modification date changed since the previous run are fetched and charged.

### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `icos` | string\[] | `["35763469","00151742"]` | 8-digit IČO (zero-padded, checksum-verified; invalid ones are reported, not charged). Up to 5,000 per run; 2 API requests each. |
| `name` | string | – | Case-insensitive substring over current **and historical** names (at least 2 characters). Legal persons and public bodies only. |
| `region` | string | – | Pre-filter on municipality or district of the registered address, diacritics-insensitive (`Kosice`). |
| `dateFrom`, `dateTo` | date | – | Keep entities established **or** terminated within the range. |
| `includeStatutoryBodies` | boolean | `true` | Adds `officers` (name, role, from/to) and `representation` (signing rules). |
| `includeHistory` | boolean | `false` | Adds `previousNames`, `previousAddresses` and former officers (with `to`). |
| `mode` | `full` / `incremental` | `full` | See *Incremental mode*. |
| `maxRecords` | integer | `1000` | Stop after this many records. |

At least one of `icos` or `name` is required.

### Output

Real record from the default input (local run on 2026-10-18). Officer names are shortened to initials in this README only — the dataset carries them as registered; the licence text is abbreviated here.

```jsonc
{
  "country": "SK", "id": "35763469", "idType": "ico",
  "name": "Slovak Telekom, a.s.", "kind": "legal-person",
  "legalForm": { "code": "121", "label": "Akciová spoločnosť" },
  "status": "active",
  "registeredAddress": { "street": "Bajkalská", "houseNumber": "28", "city": "Bratislava", "postalCode": "81762", "country": "SK", "formatted": "Bajkalská 28, 81762 Bratislava, SK" },
  "nace": { "main": { "code": "61.10", "label": "Wired telecommunications activities", "section": "J", "raw": "6110" }, "other": [] },
  "otherIds": { "rpoId": "1013242", "esa2010": "11003", "registrationNumber": "Sa/2081/B", "orsr": "Sa/2081/B" },
  "establishedOn": "1999-04-01",
  "registrations": [ { "register": "Obchodný register", "registerCode": "1", "number": "Sa/2081/B", "court": "Mestský súd Bratislava III" } ],
  "officers": [
    { "name": "M. S.", "role": "Predstavenstvo – Podpredseda predstavenstva", "roleCode": "99", "from": "2024-06-01" },
    { "name": "A. S.", "role": "Predstavenstvo – Predseda predstavenstva", "roleCode": "99", "from": "2025-04-29" }
    // … 1 more member
  ],
  "shareCapital": { "amount": 864113000, "currency": "EUR" },
  "previousNames": [],
  "representation": [ "V mene spoločnosti podpisujú aspoň dvaja členovia predstavenstva, …" /* … */ ],
  "provenance": {
    "source": "sk-rpo",
    "sourceName": "Register právnických osôb, podnikateľov a orgánov verejnej moci (RPO), SR",
    "sourceUrl": "https://rpo.statistics.sk/rpo/?orgid=1013242",
    "licence": "1. ŠÚ SR ako správca informačného systému RPO uplatňuje … Creative Commons Attribution License (cc-by) 4.0 …",
    "retrievedAt": "2026-10-18T01:57:41.705Z", "sourceUpdatedAt": "2026-10-16"
  }
}
```

Other fields: `kind` (`legal-person`, `public-body`, `natural-person-entrepreneur`, `unknown`), `status` (`active`, `in-liquidation`, `in-insolvency`, `dissolved`), `dissolvedOn`, `legalStatus { code, label, from }`, `previousAddresses[]` (with history). `provenance.licence` is the licence string the API returned in that very response; `sourceUpdatedAt` is the register's `dbModificationDate`, so the data are as fresh as the live register.

### Pricing in plain words

You pay **$3 per 1,000 records returned**, plus $0.00005 per run start. Empty results are free: not-found or invalid IČO, withheld natural persons, filtered-out entities and unchanged entities in incremental mode are never charged. On the free plan ($5 monthly credit) that is about 1,600 records a month. Bronze, Silver and Gold volume discounts are configured on the store page. The run stops gracefully at `maxRecords` or your maximum total charge.

### Limits & fair use

- The RPO API publishes **no rate limit**; it sits behind a CDN. The actor stays conservative at **1 request per second, concurrency 1**, backs off exponentially on 429/5xx (honouring `Retry-After`) and stops immediately with a clear error on HTTP 403 or an HTML/maintenance page. Expect about 2 s per IČO; 1,000 IČO take roughly 35 minutes.
- Name search has no server-side paging: the API returns every match at once (117 rows for `Telekom` on 2026-10-17); details are then fetched one by one until `maxRecords`. Use `region`, `dateFrom` and `dateTo` to pre-filter before details are fetched.
- The first request of a run can take longer than 30 s (cold CDN) and is retried automatically. Reaching `maxRecords` or your budget stops the run and keeps what was pushed.

### Incremental mode

The cursor is kept in the run's default key-value store under `CURSOR` **and mirrored to the named key-value store `sk-rpo-company-cursor`** (override with the `cursorStore` input, one per watch-list), so it survives across runs and tasks. Format: `{ "value": { "<IČO>#<rpoId>": "<dbModificationDate>" }, "updatedAt": "…" }`. Each run still performs the cheap `search` request per IČO or name (it returns `dbModificationDate`) but fetches and returns only entities whose modification date differs from the cursor; unchanged entities are skipped and not charged. The cursor is written after every run, also in `full` mode; delete `CURSOR` or run `full` to reset.

### Data protection

RPO data are public, free and informative in character by law (§ 7 ods. 2 zák. č. 272/2015 Z. z.). The register publishes no birth dates or birth numbers, but it does publish statutory-body members' names and sometimes their street addresses, and a sole trader's place of business is often a home. This actor therefore:

- returns **natural-person entrepreneurs** (živnostníci, SHR, slobodné povolania; legal-form codes 101–110, 422) only when their own IČO is in `icos`, with the address reduced to municipality and country; name searches never return them;
- returns **statutory-body members** as name, role and validity dates only — their addresses are never output; partners, shareholders, prokurists, deposits and free-text facts are not output;
- never attempts the beneficial-owner (KÚV) data, which the API does not expose;
- deep-removes any key named like a birth date, birth number, nationality, residence, e-mail or phone as a last line of defence;
- stores no personal data on the developer's side — datasets live in your Apify storage; only run statistics and the cursor are kept.

Lawful basis for the processing inside a run is Art. 6(1)(f) GDPR — legitimate interest in making statutorily public register data about economic entities machine-readable for due diligence, KYC/AML, procurement and journalism. You are the controller of what you download. Corrections or removals of register content must be requested from the register's administrator (Ministerstvo vnútra SR) or the primary register (Obchodný register, živnostenský register); `provenance.sourceUrl` opens the entity in the RPO web UI. This section describes the actor's behaviour and is not legal advice.

### FAQ

**The register changed hands — will the actor keep working?** Since 1 June 2026 the RPO is administered by the Ministry of the Interior (Ministerstvo vnútra SR) instead of the Statistical Office. The legacy API host still answers and still returns the Statistical Office's CC BY 4.0 notice. If the host, documentation or licence wording changes, the actor will be updated; the base URL is a single constant.

**Why do I get two records for one IČO?** RPO lists branches (legal form 002, "Organizačná zložka podniku") and similar units under the parent's IČO. Each RPO entity is one record; check `otherIds.rpoId` and `legalForm`.

**Why does a name search return dissolved companies or names that no longer match?** The API matches current *and historical* names; filter on `status` or set `includeHistory: true` to see the former name.

**Where are the shareholders and beneficial owners?** Shareholders and prokurists may be natural persons and are not output; beneficial owners (KÚV) are not public via the API (§ 7a).

**Why are officers' addresses missing?** On purpose — the API returns them, including foreign home addresses, and the actor drops them.

**Who invoices me?** Apify. Usage is billed to your Apify account; the developer never sees your data or payment details.

### Source & licence

Source: RPO (https://rpo.statistics.sk), licensed under Creative Commons Attribution 4.0 (CC BY 4.0) by Štatistický úrad SR; administrator since 1 June 2026: Ministerstvo vnútra SR. Data are free and informative in character (§ 7 ods. 2 zák. č. 272/2015 Z. z.).

Licence: https://creativecommons.org/licenses/by/4.0/. Data are modified: normalised to JSON, personal-data fields minimised as described above. Every record carries the licence notice exactly as returned by the API in `provenance.licence`; the authoritative extract is the register itself. Not affiliated with Štatistický úrad SR or Ministerstvo vnútra SR.

### Changelog / support

- 0.1 — first public release: IČO lookup, name search with region/date pre-filters, statutory bodies, history, incremental mode.

Questions, bugs and feature requests: use the **Issues** tab of this actor.

Documentation drafted with AI assistance and reviewed by the publisher before publication.

# Actor input Schema

## `icos` (type: `array`):

Slovak company identifiers (IČO, 8 digits; shorter values are zero-padded). Up to 5,000 per run; each costs 2 API requests at 1 request/second. Invalid checksums are reported, not charged. Natural-person entrepreneurs (živnostníci) are returned only when their IČO is listed here.

## `name` (type: `string`):

Search by (part of) the company name — case-insensitive substring over current and historical names, e.g. `Telekom`. Returns legal persons and public bodies only (natural-person entrepreneurs are withheld). The register returns all matches at once; `maxRecords` caps how many are fetched.

## `region` (type: `string`):

Optional filter on the registered address: substring match on the municipality or district, diacritics-insensitive (e.g. `Bratislava`, `Kosice`). Applied before details are fetched.

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

Keep only entities established or terminated on/after this date. ISO (YYYY-MM-DD) or DD.MM.YYYY.

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

Keep only entities established or terminated on/before this date. ISO (YYYY-MM-DD) or DD.MM.YYYY.

## `includeStatutoryBodies` (type: `boolean`):

Add `officers` (statutory-body members: name, role, valid from/to — never their addresses) and `representation` (signing rules). Only names and roles as published in the register.

## `includeHistory` (type: `boolean`):

Add `previousNames` and `previousAddresses` (with valid from/to) and former statutory-body members (with `to` dates).

## `mode` (type: `string`):

`full` returns every matching entity; `incremental` returns only entities whose register modification date (`dbModificationDate`) changed since the previous run of this actor (cursor stored in the key-value store under `CURSOR`).

## `maxRecords` (type: `integer`):

Stop after this many records (also protects your budget).

## `cursorStore` (type: `string`):

Named key-value store that keeps the incremental-mode cursor across runs (default `sk-rpo-company-cursor`). Use a different name per watch-list.

## Actor input object example

```json
{
  "icos": [
    "35763469",
    "00151742"
  ],
  "includeStatutoryBodies": true,
  "includeHistory": false,
  "mode": "full",
  "maxRecords": 1000
}
```

# Actor output Schema

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

All records returned by this run (full JSON).

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

No description

## `stats` (type: `string`):

Records requested, returned and charged, plus source request counts.

# 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 = {
    "icos": [
        "35763469",
        "00151742"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietpinelabs/sk-rpo-company").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 = { "icos": [
        "35763469",
        "00151742",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("quietpinelabs/sk-rpo-company").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 '{
  "icos": [
    "35763469",
    "00151742"
  ]
}' |
apify call quietpinelabs/sk-rpo-company --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quietpinelabs/sk-rpo-company"
        }
    }
}
```

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/tSl5LiP71947PhU3w/builds/fgWqweIaxVyONrTvK/openapi.json