# Czech Contract Register (Registr smluv) → JSON (`quietpinelabs/registr-smluv-contracts`) Actor

Contracts from the Czech Registr smluv open-data dumps (smlouvy.gov.cz) as clean JSON: publisher, parties, subject, value, attachments metadata. Filter by IČO, name, date, value. Natural persons redacted.

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

## Pricing

from $1.40 / 1,000 contracts

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

## Czech public contracts from Registr smluv as clean JSON — by IČO, party name or date

Get every contract published in the Czech **Registr smluv** (the statutory contract register at smlouvy.gov.cz, operated by Digitální a informační agentura) as one clean JSON record: publisher, contracting parties, subject, contract number, signature date, value excluding and including VAT, attachment metadata and a deep link. The actor streams the register's official open-data XML dumps (no HTML scraping, no third-party mirror, no attachment downloads), filters them by IČO, party name, date and value, redacts natural persons by default and, in `incremental` mode, returns each new contract exactly once.

### Who uses it

- **Compliance and KYC teams** — see what a supplier or customer has signed with the Czech public sector, by IČO.
- **Sales and market-intelligence teams** — watch new contracts of a ministry, hospital or city and route them to a CRM via Make, Zapier or n8n.
- **Journalists, NGOs and data engineers** — public spending as JSON instead of 80–185 MB XML files.

### Use cases

**1. All contracts of two counterparties published this month:**

```json
{ "icos": ["27661989", "45359326"] }
```

Contracts where the publisher or any party has one of these IČO; with a filter and no dates, the range is the current month to date.

**2. Hospital contracts above 1 million CZK signed in Q3 2026:**

```json
{ "name": "nemocnice", "minValueCzk": 1000000, "dateFrom": "2026-07-01", "dateTo": "2026-09-30", "dateField": "concluded" }
```

Publisher or organisation party name contains "nemocnice" and the CZK value is at least 1,000,000.

**3. Daily feed of everything new (schedule as a task):**

```json
{ "mode": "incremental", "cursorStore": "smluv-daily" }
```

Streams the daily dumps published since the last run; each contract is returned once.

### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `icos` | string\[] | `[]` | Keep contracts where the publisher or any party has one of these IČO (checksum-validated; up to 5,000). |
| `name` | string | – | Case- and diacritics-insensitive substring on the publisher name and organisation party names. Redacted persons never match. |
| `dateFrom`, `dateTo` | date | yesterday / current month | Inclusive range, at most **93 days per run**; `dateTo` is clamped to today. |
| `dateField` | `published` / `concluded` | `published` | Publication day in the register (dumps are partitioned by it) or signature date. |
| `minValueCzk` | integer | – | Keep contracts whose CZK value (excl. or incl. VAT, whichever is higher) is at least this. Records without a CZK value are dropped when set. |
| `includeAttachmentsMeta` | boolean | `true` | Include `attachments[]` (file name, SHA-256, URL). Files are never downloaded. |
| `includeInvalid` | boolean | `false` | Also return record versions flagged `platnyZaznam = 0` (superseded or invalidated). |
| `mode` | `full` / `incremental` | `full` | See *Incremental mode*. |
| `cursorStore` | string | `registr-smluv-contracts` | Named key-value store that keeps the incremental cursor between runs. |
| `maxRecords` | integer | `1000` | Stop after this many contracts. |

Date defaults: no dates and no `icos`/`name` → yesterday's daily dump only; no dates but a filter → first day of the current month to today; only `dateFrom` → until today; only `dateTo` → from the first day of that month.

### Output

One item per contract record version. Real record from the default input (`maxRecords: 20`, yesterday's daily dump, local run on 2026-10-18):

```json
{
  "country": "CZ",
  "id": "37597061",
  "version": "39979257",
  "url": "https://smlouvy.gov.cz/smlouva/39979257",
  "publishedAt": "2026-10-16T22:03:44.000Z",
  "publisher": {
    "name": "Krajská nemocnice T. Bati, a. s.",
    "ico": "27661989",
    "address": { "street": "Havlíčkovo nábřeží", "houseNumber": "600", "city": "Zlín", "postalCode": "76001", "country": "CZ", "formatted": "Havlíčkovo nábřeží 600, 76001 Zlín, CZ" }
  },
  "parties": [
    { "type": "organisation", "name": "Merck Sharp & Dohme s.r.o.", "ico": "28462564",
      "address": { "street": "Na Valentince", "houseNumber": "3336/4", "city": "Praha", "postalCode": "15000", "country": "CZ", "formatted": "Na Valentince 3336/4, 150 00 Praha" } }
  ],
  "subject": "Objednávka OZL/LEK/26/33188",
  "contractNumber": "OZL/LEK/26/33188",
  "concludedOn": "2026-10-16",
  "valueExclVat": { "amount": 312180.2, "currency": "CZK" },
  "priceNotStated": false,
  "attachments": [
    { "fileName": "OZL_LEK_26_33188_RS.pdf", "sha256": "ab853a2ec95d5195668fae2f81bca468e8743138f278837ac0115e35657d446e", "url": "https://smlouvy.gov.cz/smlouva/soubor/48174145/OZL_LEK_26_33188_RS.pdf" }
  ],
  "isValid": true,
  "provenance": {
    "source": "registr-smluv",
    "sourceName": "Registr smluv, Digitální a informační agentura",
    "sourceUrl": "https://smlouvy.gov.cz/smlouva/39979257",
    "licence": "Zdroj: Registr smluv (https://smlouvy.gov.cz), open data under zák. č. 340/2015 Sb. Recipients of this data are independent GDPR controllers; records made inaccessible at the source must be deleted.",
    "retrievedAt": "2026-10-18T02:08:39.714Z",
    "sourceUpdatedAt": "2026-10-17"
  }
}
```

Field notes: `id` is the stable contract ID, `version` the published version (a new version is a new item). `publishedAt` is UTC; date filters use the register's Czech local day. Parties are `{ "type": "organisation", name, ico?, address?, isRecipient? }` or `{ "type": "natural-person", "redacted": true }`. Values come from the CZK fields (negative on amendments); a foreign-currency amount fills the field the publisher left empty, with its own currency. `priceNotStated` means the publisher gave a reason instead of a price; `linkedRecordId` points to the parent contract of an amendment. Addresses are best-effort parses of free text; `formatted` always holds the original. Run statistics are in the key-value store record `STATS`.

### Pricing in plain words

You pay **$2 per 1,000 contracts returned**, plus **$0.01 per run start** — higher than our other actors because every run must download and stream the register's official XML dumps (0.1–185 MB) even when few records match. Empty results are free apart from the start fee. On the free plan ($5 monthly credit) that is about 2,300 contracts a month with one run a day. Bronze, Silver and Gold volume discounts are configured on the store page. The run stops gracefully at `maxRecords` or your maximum total charge; keep date ranges short and use incremental mode for monitoring.

### Limits & fair use

- The register publishes **no rate limit**. The actor downloads from `data.smlouvy.gov.cz` only, at **1 request per second with at most 2 downloads in flight**, verifies each dump's SHA-1 against `index.xml` and fails fast with a clear message when the server returns HTML (maintenance) or a truncated file.
- A date range covers at most **93 days per run**. Daily dumps (0.1–15 MB, about 4,500 records on a working day) are used when the range starts within the last 45 days or in incremental mode; otherwise monthly dumps of 80–185 MB (about 90,000–110,000 records) are streamed at roughly 0.5–3 minutes per month, with flat memory because records are parsed one at a time.
- `concluded` filtering is limited to the dumps selected by the same range: a contract signed in March but published in May is found only with a range covering May.
- Reaching `maxRecords` or your budget stops the run and keeps what was pushed.

### Incremental mode

`mode: "incremental"` processes daily dumps only. The cursor `{ "value": { "lastDumpDate": "YYYY-MM-DD", "seenIds": ["idSmlouvy:idVerze", …] }, "updatedAt": "…" }` is stored under `CURSOR` in the run's default key-value store (read first, so you can seed or reset it) and in the named store `cursorStore`, which survives across runs — use a different name per configuration. The first run behaves like `full` over the resolved range (default: yesterday). Later runs stream the daily dumps from `lastDumpDate` to today and skip the `seenIds` of the last day, which is re-read because its dump may have been incomplete. `dateFrom`/`dateTo` are ignored once a cursor exists; gaps longer than 93 days are cut to 93. If `maxRecords` or the budget stops the run mid-day, `seenIds` holds only the records actually processed, so the next run continues without duplicates or gaps.

### Data protection

The register's terms say the open dataset contains personal data and that its recipient becomes an independent GDPR controller; publishers, not the register, anonymise contracts (§ 5(8) of Act No. 340/2015 Coll.), so natural persons' names do appear in the dumps. This actor:

- replaces every party flagged `FO`/`ZFO` (natural person) with `{ "type": "natural-person", "redacted": true }`;
- redacts parties flagged `PFO` (natural-person entrepreneurs), and unflagged parties whose name looks like a personal name, unless their own IČO is in `icos` — and even then reduces their address to the municipality;
- never outputs `schvalil` (the signatory), `datovaSchranka` or `platce`, and never fetches attachment contents;
- matches `name` against organisations only, so a person cannot be looked up by name;
- applies a key deny-list to every item as a last line of defence;
- re-reads the regenerated dumps on every run and caches nothing but the incremental cursor (IDs only), so records the register makes inaccessible disappear from later runs; if you store datasets long-term, re-sync periodically and delete removed records, as the register's terms require.

Lawful basis for the processing inside a run is Art. 6(1)(f) GDPR — legitimate interest in making data that is public by law machine-readable for due diligence, procurement analysis and journalism. You are the controller of what you download. Removal requests for register content go to the register (registrsmluv@mvcr.cz); each record's `url` opens it on smlouvy.gov.cz. This section describes the actor's behaviour and is not legal advice.

### FAQ

**Why dumps and not a search API?** The register offers no public read API; its only machine channel is open-data dumps, and its web search is HTML, which this actor does not scrape. That is also why a run with two IČO still streams the whole day's or month's dump and carries a start fee.

**A party shows as `redacted`. Can I get the name?** Only for natural-person entrepreneurs whose own IČO you supply in `icos`; private individuals are never returned.

**Can I get the contract text or PDF?** No — attachments are never downloaded; `attachments[]` gives the file name, SHA-256 and URL so you can fetch them yourself under the register's terms.

**How fresh is the data?** Daily dumps are generated around 04:30 Czech time for the previous day; yesterday's dump may still be flagged incomplete and is re-read by incremental mode. Monthly dumps are regenerated nightly, which is also how records the register made inaccessible vanish between runs — delete them from your copies too.

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

### Source & licence

Zdroj: Registr smluv (https://smlouvy.gov.cz), open data under zák. č. 340/2015 Sb. Recipients of this data are independent GDPR controllers; records made inaccessible at the source must be deleted.

Terms of use: https://smlouvy.gov.cz/stranka/otevrena-data. Catalogue record: https://data.gov.cz/zdroj/datové-sady/17651921/a9945c027cf6ca67d959e8eb04885f22. Each record carries the attribution in `provenance.licence`. Not affiliated with Digitální a informační agentura or the Ministry of the Interior of the Czech Republic.

### Changelog / support

- 0.1 — first public release: daily and monthly dump streaming, IČO/name/date/value filters, natural-person redaction, 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`):

Return contracts where the publisher or any contracting party has one of these IČO (8 digits, checksum validated; up to 5,000). Natural-person entrepreneurs (PFO) are shown un-redacted only when their own IČO is listed here. Leave empty to return all contracts in the date range.

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

Case- and diacritics-insensitive substring matched against the publisher name and organisation party names (e.g. `nemocnice`, `cez`). Redacted natural persons never match.

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

ISO date (YYYY-MM-DD) or DD.MM.YYYY. With no dates and no `icos`/`name` the actor processes yesterday's daily dump only; with filters it defaults to the current month up to today. A range may span at most 93 days (≈ 3 months) per run.

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

ISO date (YYYY-MM-DD) or DD.MM.YYYY, inclusive. Defaults to today (clamped to today).

## `dateField` (type: `string`):

Which date `dateFrom`/`dateTo` apply to: `published` = publication in the register (casZverejneni; dumps are partitioned by this date), `concluded` = signature date (datumUzavreni) — matched only within the dumps selected for the same range.

## `minValueCzk` (type: `integer`):

Keep only contracts whose value (excl. or incl. VAT, whichever is higher) is at least this many CZK. Contracts without a CZK value (price not stated, foreign currency only) are dropped when this is set.

## `includeAttachmentsMeta` (type: `boolean`):

Include file name, SHA-256 and download URL of each attachment. Attachment files are never downloaded or read by this actor.

## `includeInvalid` (type: `boolean`):

Also return record versions flagged `platnyZaznam = 0` (superseded/invalidated). Default: only valid records.

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

Not supported by Registr smluv dumps — accepted for interface compatibility and ignored.

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

`full` streams the dumps covering the date range. `incremental` processes only daily dumps published after the cursor stored in the key-value store (`CURSOR`), so repeated runs return each contract once.

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

Name of the key-value store that keeps the incremental cursor between runs (the run's default store is per run on the platform). Use different names for different incremental configurations.

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

Stop after this many contracts (also protects your budget). The default input (no filters, yesterday's dump) returns the first 20 contracts.

## Actor input object example

```json
{
  "icos": [],
  "dateField": "published",
  "includeAttachmentsMeta": true,
  "includeInvalid": false,
  "mode": "full",
  "cursorStore": "registr-smluv-contracts",
  "maxRecords": 20
}
```

# 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": [],
    "maxRecords": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietpinelabs/registr-smluv-contracts").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": [],
    "maxRecords": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("quietpinelabs/registr-smluv-contracts").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": [],
  "maxRecords": 20
}' |
apify call quietpinelabs/registr-smluv-contracts --silent --output-dataset

```

## MCP server setup

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

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/SgRfAs90JMx4YJZCU/builds/TZHBKyjUG6HGHEG7w/openapi.json