# ARES Czech Business Registry Scraper (`parseforge/ares-czech-scraper`) Actor

Scrape Czech business registry data from ARES. Get company names, ICO numbers, VAT IDs, addresses, NACE industry codes, legal forms, and registration dates for 3M+ Czech businesses. Search by name, ICO, or legal form.

- **URL**: https://apify.com/parseforge/ares-czech-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇨🇿 ARES Czech Business Registry Scraper

> 🚀 **Export Czech company records in bulk from the official ARES registry.** Pull names, IČO IDs, legal forms, DIČ tax IDs, addresses, regions, and registration dates. No API key, no manual lookup, no CSV wrangling.

> 🕒 **Last updated:** 2026-05-12 · **📊 25+ fields** per record · **🇨🇿 All Czech entities** · **🏢 50+ legal forms** · **🔍 Search by name, IČO, or legal form**

The **ARES Czech Business Registry Scraper** queries the Ministry of Finance's official Czech business registry (ARES) and returns **25+ fields per company**, including name, 8-digit IČO, legal form code and label, DIČ tax ID, full registered address, region (kraj), municipality (obec), and registration metadata. The registry is the authoritative source for company information in the Czech Republic.

Coverage spans **every Czech legal entity** with an IČO, from joint-stock companies (a.s.) and limited liability (s.r.o.) to cooperatives, foundations, public bodies, and self-employed traders. This Actor exposes name-based search, direct IČO lookup, and legal-form filtering with server-side pagination.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Compliance teams, due-diligence analysts, AML/KYC officers, B2B sales, journalists, supplier-onboarding teams | Sanctions and PEP screening, invoice validation, supplier databases, fraud detection, beneficial ownership research, market research |

---

### 📋 What the ARES Scraper does

Three filtering workflows in a single run:

- 🔍 **Search by name.** Partial match against the legal company name (e.g. `Skoda` returns every Skoda-related entity).
- 🆔 **Lookup by IČO.** Direct fetch of a single company by its 8-digit Czech registration ID.
- 🏷️ **Filter by legal form.** Restrict to a specific entity type via the official legal-form code (e.g. `121` for joint-stock).

Each record includes the company's IČO, name, legal form (code and label), tax registration status (DIČ), date of incorporation, full registered seat address, region (kraj), municipality (obec), financial office jurisdiction, and the complete raw ARES payload for downstream processing.

> 💡 **Why it matters:** the Czech business registry is the canonical source for company data in the country. Compliance teams use it for sanctions screening, sales teams use it for supplier onboarding, journalists use it for investigative reporting. This Actor lifts the bulk-export limitation that ARES's web UI imposes.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing bulk export of every joint-stock company in Prague._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>searchQuery</td><td>string</td><td>"Skoda"</td><td>Partial-match search on company name. Required unless ico is set.</td></tr>
<tr><td>ico</td><td>string</td><td>null</td><td>8-digit Czech company ID. When provided, performs a direct lookup.</td></tr>
<tr><td>legalForm</td><td>string</td><td>null</td><td>Official legal-form code. 121 = joint-stock (a.s.), 112 = limited liability (s.r.o.), etc.</td></tr>
</tbody>
</table>

**Example: 500 companies with "Praha" in their name.**

```json
{
    "maxItems": 500,
    "searchQuery": "Praha"
}
````

**Example: every joint-stock company (legal form 121).**

```json
{
    "maxItems": 1000,
    "legalForm": "121"
}
```

**Example: direct IČO lookup.**

```json
{
    "ico": "00177041"
}
```

> ⚠️ **Good to Know:** ARES is updated daily by the Ministry of Finance, so freshly registered companies appear within 24-48 hours. Some legal forms (foundations, public institutions) include extra metadata that is not present on commercial entities.

***

### 📊 Output

Each record contains **25+ fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `ico` | string | `"00177041"` |
| 🏢 `name` | string | `"ŠKODA AUTO a.s."` |
| 🏷️ `legalFormCode` | string | `"121"` |
| 🏷️ `legalFormLabel` | string | `"Akciová společnost"` |
| 💼 `dic` | string | null | `"CZ00177041"` |
| 📅 `createdAt` | string | null | `"1991-04-20"` |
| 📅 `lastUpdate` | string | `"2026-04-30"` |
| 🏠 `addressStreet` | string | `"tř. Václava Klementa"` |
| 🔢 `addressHouseNumber` | string | `"869"` |
| 🏙️ `addressCity` | string | `"Mladá Boleslav"` |
| 📮 `addressZip` | string | `"29301"` |
| 🌍 `addressRegion` | string | `"Středočeský kraj"` |
| 🏛️ `addressMunicipality` | string | `"Mladá Boleslav"` |
| 🏦 `taxOfficeJurisdiction` | string | null | `"FÚ pro Středočeský kraj"` |
| 🌐 `aresUrl` | string | `"https://ares.gov.cz/ekonomicke-subjekty/00177041"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-12T00:00:00.000Z"` |
| 📦 `raw` | object | full ARES response |

#### 📦 Sample record

<details>
<summary><strong>🚗 ŠKODA AUTO a.s.</strong></summary>

```json
{
    "ico": "00177041",
    "name": "ŠKODA AUTO a.s.",
    "legalFormCode": "121",
    "legalFormLabel": "Akciová společnost",
    "dic": "CZ00177041",
    "createdAt": "1991-04-20",
    "lastUpdate": "2026-04-30",
    "addressStreet": "tř. Václava Klementa",
    "addressHouseNumber": "869",
    "addressCity": "Mladá Boleslav",
    "addressZip": "29301",
    "addressRegion": "Středočeský kraj",
    "addressMunicipality": "Mladá Boleslav",
    "taxOfficeJurisdiction": "Specializovaný finanční úřad",
    "aresUrl": "https://ares.gov.cz/ekonomicke-subjekty/00177041",
    "scrapedAt": "2026-05-12T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏛️ | **Official ARES data.** Pulls directly from the Czech Ministry of Finance's authoritative registry. |
| 🇨🇿 | **Full country coverage.** Every Czech legal entity with an IČO, across 50+ legal forms. |
| 🔍 | **Three search modes.** Name partial match, direct IČO lookup, or legal-form filter. |
| 📦 | **Raw payload preserved.** The full original ARES response is returned alongside the normalized fields. |
| ⚡ | **Fast.** 100 companies in under 10 seconds, 10,000 records in under 5 minutes. |
| 🚫 | **No authentication.** Works with public registry data. No login or API key needed. |
| 🔁 | **Always fresh.** Every run pulls the latest data, so registrations from the past 24 hours are included. |

> 📊 The Czech business registry holds records on roughly 3 million entities. This Actor lifts the per-query cap that the ARES website imposes.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ ARES Czech Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All Czech entities** | **Daily** | name, IČO, legal form | ⚡ 2 min |
| Manual ARES web UI | Free | Limited per session | Daily | Same filters | 🐢 Hours per batch |
| Paid Czech business data providers | $100+/month | Often broader (history, owners) | Variable | Many | ⏳ Days of integration |

Pick this Actor when you need bulk export of Czech registry data without paying for commercial providers.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the ARES Czech Business Registry Scraper page on the Apify Store.
3. 🎯 **Set input.** Choose a search query, IČO, or legal form code.
4. 🚀 **Run it.** Click **Start** and let the Actor fetch and structure the records.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ Compliance and KYC

- AML and PEP screening against company registries
- Beneficial-ownership and group structure research
- Sanctions list cross-referencing
- Continuous monitoring of supplier registrations

</td>
<td width="50%" valign="top">

#### 🤝 Sales and B2B Marketing

- Build prospect lists by legal form, region, or industry
- Enrich CRM records with verified IČO and DIČ
- Identify newly registered companies for outbound
- Validate invoices and counterparty data

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Market and Investment Research

- Map the Czech corporate landscape by sector and region
- Identify acquisition targets by legal form
- Track formation and dissolution trends
- Build proprietary economic indicators

</td>
<td width="50%" valign="top">

#### 🤝 Supplier Onboarding

- Verify supplier identity before contract signing
- Populate vendor management systems from a single source
- Spot duplicates and shell entities
- Run ongoing checks on the supplier base

</td>
</tr>
</table>

***

### 🔌 Automating ARES Czech Scraper

Control the scraper programmatically for scheduled refreshes and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A daily refresh keeps downstream KYC and supplier databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support journalism, academic research, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Studies of Czech corporate formation patterns
- Datasets for economics and business school coursework
- Reproducible studies with cited, versioned dataset pulls
- Comparative legal-form analyses

</td>
<td width="50%">

#### 📰 Journalism

- Investigative reporting on shell companies and ownership
- Local journalism on regional business activity
- Verification of company identity in news stories
- Open-data publishing for civic accountability

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency tools for citizen access to registry data
- Sectoral mapping for NGOs and trade associations
- Beneficial-ownership and anti-corruption work
- Public-interest databases on Czech entities

</td>
<td width="50%">

#### 🧪 Experimentation

- Train named-entity recognition or address parsers
- Prototype fintech and B2B tools with real registry data
- Validate CRM enrichment hypotheses with bulk samples
- Test compliance pipelines end-to-end

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20ARES%20Czech%20Business%20Registry%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20ARES%20Czech%20Business%20Registry%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20ARES%20Czech%20Business%20Registry%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20ARES%20Czech%20Business%20Registry%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

You configure the input form with a search query, IČO, or legal form code, click Start, and the Actor queries the ARES API directly. Each match is normalized into a flat record and pushed to the dataset.

#### 📏 How accurate is the data?

The data comes from the Czech Ministry of Finance's official registry. Accuracy is whatever ARES publishes. The Actor does not modify any field beyond reorganizing it into a flatter structure for downstream use.

#### 🔁 How often is the dataset refreshed?

ARES is updated daily by the Ministry of Finance. Every Actor run fetches the latest data, so registrations and updates from the past 24-48 hours are picked up.

#### 🆔 What is an IČO?

IČO (Identifikační číslo osoby) is the 8-digit unique business identification number that the Czech Republic assigns to every registered legal entity. It's the equivalent of a US EIN or a UK Company Number.

#### 💼 What is DIČ?

DIČ (Daňové identifikační číslo) is the Czech tax identification number, typically formatted as `CZ` + the IČO (e.g. `CZ00177041`). Not every IČO has a DIČ, only entities registered for VAT do.

#### 🏷️ What legal form codes are supported?

The most common Czech legal forms include `121` (Akciová společnost, joint-stock), `112` (Společnost s ručením omezeným, limited liability), `101` (Fyzická osoba podnikající, sole trader), `141` (Družstvo, cooperative), and others. The full list is published by the Czech Statistical Office.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. Daily schedules align with ARES's own update cadence.

#### ⚖️ Is this data legal to use?

The ARES registry is a public dataset and its records can be freely used for commercial and non-commercial purposes within the Czech Republic and abroad. Review the Ministry of Finance's terms for any specific licensing restrictions.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit to 1,000,000 records and unlocks scheduling and higher concurrency.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

ARES Czech Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe registry data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh ARES records into your CRM, or alert your compliance team about newly registered entities.

***

### 🔗 Recommended Actors

- [**🏛️ GLEIF LEI Scraper**](https://apify.com/parseforge/gleif-lei-scraper) - Global legal entity identifiers
- [**🏢 Spain Empresia Scraper**](https://apify.com/parseforge/spain-empresia-scraper) - Spanish business registry data
- [**📊 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker and firm regulatory records
- [**🏦 FDIC Bank Scraper**](https://apify.com/parseforge/fdic-bank-scraper) - U.S. bank financial data
- [**🇪🇺 Europages B2B Scraper**](https://apify.com/parseforge/europages-scraper) - European B2B supplier directory

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more business registry scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Czech Ministry of Finance, ARES, or any government agency. All trademarks mentioned are the property of their respective owners. Only publicly available registry data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Search by company name (partial match). Example: 'Skoda'

## `ico` (type: `string`):

Czech company ID. Overrides search query if provided.

## `legalForm` (type: `string`):

e.g. '121' (joint-stock company), '112' (limited liability)

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "Skoda"
}
```

# 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 = {
    "maxItems": 10,
    "searchQuery": "Skoda"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ares-czech-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 = {
    "maxItems": 10,
    "searchQuery": "Skoda",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ares-czech-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 '{
  "maxItems": 10,
  "searchQuery": "Skoda"
}' |
apify call parseforge/ares-czech-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/ares-czech-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ARES Czech Business Registry Scraper",
        "description": "Scrape Czech business registry data from ARES. Get company names, ICO numbers, VAT IDs, addresses, NACE industry codes, legal forms, and registration dates for 3M+ Czech businesses. Search by name, ICO, or legal form.",
        "version": "1.0",
        "x-build-id": "E0ynhgV8U73ImcGXv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ares-czech-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ares-czech-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/parseforge~ares-czech-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ares-czech-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/parseforge~ares-czech-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ares-czech-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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchQuery": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Search by company name (partial match). Example: 'Skoda'"
                    },
                    "ico": {
                        "title": "IČO (Company ID)",
                        "type": "string",
                        "description": "Czech company ID. Overrides search query if provided."
                    },
                    "legalForm": {
                        "title": "Legal Form Code",
                        "type": "string",
                        "description": "e.g. '121' (joint-stock company), '112' (limited liability)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
