# Slovakia RUZ Filing Changes & Corrections Metadata (`thatmike1/sk-ruz-corrections`) Actor

Read Slovak RÚZ changed accounting units, statements, financial reports and annual-report metadata. Export official IDs, filing dates, attachment hashes and bounded continuation receipts. Current observations, not a complete revision history.

- **URL**: https://apify.com/thatmike1/sk-ruz-corrections.md
- **Developed by:** [Michal Pšenčík](https://apify.com/thatmike1) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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

## Slovakia RUZ Filing Changes & Corrections Metadata

Read the four anonymous Slovak RÚZ modified-ID feeds: accounting units, accounting statements,
financial reports and annual reports. Get current filing metadata, official parent IDs, attachment
hashes and an explicit coverage receipt. Old accounting periods can change today: the source's
statement 2222095 covers 2014, was filed in 2015 and was modified in October 2026.

This is a bounded metadata-feed experiment. It does not establish a complete revision history,
prove a legally filed correction, or distinguish new records from corrections.

### Input

```
{
    "changedSince": "2026-10-16",
    "entityTypes": ["statement"],
    "pageSize": 1,
    "maxPagesPerFeed": 1,
    "maxRows": 1,
    "requestIntervalMs": 2000
}
```

Omitted changedSince resolves once to yesterday UTC; only calendar dates from 2000 onward are
accepted. Defaults select statement, report, annual_report, unit in that order, 10 IDs/page,
one page/feed and 20 aggregate observations. Bounds are 1–25 IDs/page, 1–4 pages/feed and 1–100
rows/run. maxRows must be at least pageSize. Feeds rotate by whole page. The request interval
accepts 1100–5000 ms; this build always waits at least 2000 ms after completion.

Pass previousVersions with at most 1000 keys like
"ruz:statement:2222095": {"metadataHash":"<64 lowercase hex>","sourceModifiedDate":"2026-10-16","sourceStatus":null}.
Hashes must use previousNormalizationVersion "1". The Actor compares only entities it encounters;
it has no persistent watch database. A later run can supply the prior row's hash/date/status.

### Output and resuming

Each paid dataset row has the complete version-1 schema: sourceKey/sourceId/entityType/sourceUrl,
source date/status/deleted, metadata, metadataHash/versionId, comparison fields, fetchedAt,
apiVersion and warnings. Metadata contains official IDs, periods, submission/preparation/approval
dates, accessibility, classification codes, child IDs and attachment ID/MIME/bytes/pages/language/hash.
Missing scalars are null and unexposed arrays empty. Empty arrays do not prove source-wide absence.
Names, addresses, IČO, DIČ, cover-sheet identity, filenames, financial tables and PDFs are excluded.
Nonpublic unit metadata is suppressed entirely; report visibility gates content and attachments.

changeType is observed, metadata_changed, source_date_changed, unchanged or source_deleted.
Only exact source ZMAZANÉ is deletion; neither absence nor a failed HTTP request implies deletion.
versionId identifies a canonical observed version; A→B→A reuses A's ID. It is a downstream dedup key,
not a unique billing receipt.

Free default KV records SUMMARY and OUTPUT report coverage, errors and a portable continuation.
SUMMARY includes per-feed pages/IDs/stored rows/afterId/complete, attempts, response bytes, emitted
version IDs and resumeAdvice. RUN_STATE is internal run-local migration bookkeeping.
Reserve pageSize free row slots before starting a page. Leftover capacity may be unused.
A page cursor advances only after every listed row is verified in dataset storage. A failed or
interrupted page keeps its old cursor; replayed prefix observations may be delivered and billed again.

For ordinary row/page caps only, autoResumeAllowed is true. Pass the exact continuation, same
changedSince/entityTypes and same pageSize; explicitly reducing pageSize is allowed for recovery.
Never invent a large cursor. Receipts expire after seven days. Operational interruptions disable
automatic resume: inspect delivery, resolve the error, raise the platform allowance, or reduce
pageSize as SUMMARY directs. A one-ID page that still fails needs investigation.
After completion, start a fresh sweep using nextChangedSince (original sweep UTC start day minus
one), with fresh cursors. A complete sweep means observed feed ends, not an immutable register snapshot.
Serialize runs sharing one consumer cursor and update downstream baselines only from stored rows.

### Pricing

Configured reference prices: **$0.00005 per automatic start unit** and **$0.001 per useful dataset
observation stored**. Unchanged checks, overlapping/replayed checks and explicit tombstones cost
the same as changed observations. Parent enrichment has no separate item. Errors, empty results
and KV coverage have no item fee; every run can still incur its platform start fee.
Ten delivered rows plus one start total $0.01005 in reference event fees. Actual platform allocation,
usage mode and pricing configuration determine the invoice; local logs do not verify prices.

### Limits and source

HTTP only, fixed HTTPS origin, one request in flight, at least two seconds idle after every attempt,
two bounded retries for transient errors. All redirects must retain the allowlisted route/query.
403, challenge/HTML and 429 stop the entire source without bypass. Retry-After appears in SUMMARY.
400/404 are errors, never fabricated empty feeds or tombstones.

Ceilings: 100 HTTP attempts including parents/retries/redirects, 20 seconds/attempt,
2 MiB decoded response, 32 MiB conservative external traffic accounting, 300 seconds source work,
8 MiB internal serialized storage traffic, 128 KiB/row, and 500 operations per storage category.
Budget reservations can stop earlier: before every push the Actor reserves the push's readback and
receipt writes, and checks the remaining spending allowance. It uses the smaller of the SDK allowance
and the run's total charge cap minus verified stored-row costs and the start event. The durable
delivery ledger also counts committed appends whose responses were lost, and is checked against
dataset readback on restart. Storage API operations use no SDK retries and a twenty-second timeout.
Each append is attempted once; after a lost response, exact dataset count and row readback decide
whether it was stored. An unconfirmed append is reported as delivery_uncertain with that row's
versionId and is never replayed automatically. Migration resumes only reconciled stored
rows, with the halt reason, Retry-After and request pacing intact; an interrupted
HTTP operation fails closed because its final attempt/traffic state is uncertain.
Final receipts on a hard kill are best effort; use the last durable checkpoint.

Source: [RÚZ Open API](https://www.registeruz.sk/cruz-public/home/api), published under CC0.
The free native API is an alternative. Current metadata is not historical versions; child changes
need not update parent dates and records may disappear without tombstones. UTC overlap is a cautious
polling recommendation, not proof of source timezone or completeness. No cloud throughput guarantee.

Official IDs can relate to natural persons. The Actor user is the controller for downstream
personal-data processing; use an appropriate purpose and retention policy. Do not enrich or infer
personal details. Raw development fixtures contain published source data outside the output whitelist.

Apify-IP access, real platform billing/spend behavior, allocated memory and invoices must be
verified before publication. Quiet/empty-scan economics and buyer demand remain unverified.

# Actor input Schema

## `changedSince` (type: `string`):

ISO date, 2000-01-01 through today UTC. Omit for yesterday UTC. V1 rejects timestamps.

## `entityTypes` (type: `array`):

Unique nonempty selected feeds, processed in caller order by whole page.

## `pageSize` (type: `integer`):

Reserve this many unused row slots before each page. Explicitly reduce for recovery.

## `maxPagesPerFeed` (type: `integer`):

Per-run page cap.

## `maxRows` (type: `integer`):

Aggregate cap, at least pageSize. Useful unchanged/replayed observations are billed too.

## `requestIntervalMs` (type: `integer`):

V1 accepts 1100–5000; this build enforces at least 2000 ms for polite access.

## `previousNormalizationVersion` (type: `string`):

Only normalization 1 is compatible.

## `previousVersions` (type: `object`):

At most 1000 ruz:type:id keys; each exact {metadataHash, sourceModifiedDate, sourceStatus}. Only encountered keys are compared.

## `continuation` (type: `object`):

Paste the exact free SUMMARY receipt; omit for a new sweep. Expires after seven days. Query scope must match; pageSize may explicitly decrease.

## Actor input object example

```json
{
  "entityTypes": [
    "statement",
    "report",
    "annual_report",
    "unit"
  ],
  "pageSize": 10,
  "maxPagesPerFeed": 1,
  "maxRows": 20,
  "requestIntervalMs": 2000,
  "previousNormalizationVersion": "1",
  "previousVersions": {}
}
```

# Actor output Schema

## `rows` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `output` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thatmike1/sk-ruz-corrections").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thatmike1/sk-ruz-corrections").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 '{}' |
apify call thatmike1/sk-ruz-corrections --silent --output-dataset

```

## MCP server setup

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

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/fOJwJqd0cl1lkXClD/builds/4Lhf8hjW1Q3zzsWMI/openapi.json