# Czech Public Auctions Scraper - Portál dražeb (`regdata/czech-drazby-auction-scraper`) Actor

Track every auction run by Czech judicial executors: foreclosed flats, houses, land, vehicles and whole companies with the appraised value, the reserve price and the discount between them, the deposit, the property address with coordinates and the published appraisal PDF.

- **URL**: https://apify.com/regdata/czech-drazby-auction-scraper.md
- **Developed by:** [getregdata](https://apify.com/regdata) (community)
- **Categories:** Real estate, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 auction 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Czech Public Auctions & Foreclosures Scraper - Portál dražeb

Every auction run by a Czech judicial executor (soudní exekutor), as structured JSON: the
**appraised value**, the **reserve price** and the discount between them, the security deposit and
the account it is paid into, the **property address with coordinates** from the official RÚIAN
address registry, the executor's office, and direct links to the published **auction decree** and
**expert appraisal** PDFs.

Source: **Portál dražeb** - the register in which Czech judicial executors are required to publish
their auctions. Foreclosed flats, houses, land, garages, commercial units, vehicles, movable
property and whole companies.

No account, no API key, no proxy, nothing to configure.

---

### What do I get for one auction?

| | |
|---|---|
| **Identity** | Executor case number (`217EX00380/25-372`), register id, public URL, status |
| **The lot** | Title, description, category, tags, real estate vs movable property |
| **Money** | Appraised value, reserve price, **derived discount %**, minimum bid increment, current bid |
| **Deposit** | Dražební jistota amount, account number, IBAN, variable symbol |
| **Timing** | Start, end, original end, publication date, days until it opens |
| **Where** | Region, district, city, municipal district, street, house number, **latitude/longitude**, RÚIAN address and municipality codes |
| **Who runs it** | Executor number, name, district, website, contact email |
| **Paperwork** | Auction decree and expert appraisal PDFs with type, size and a direct download URL |
| **Process** | Open objections, repeat-auction number, bid history and result (optional) |

```json
{
  "auctionNumber": "217EX00380/25-372",
  "url": "https://www.portaldrazeb.cz/drazba/217ex00380-25-372-ykokb",
  "title": "Ideální spoluvlastnický podíl 1/12 jednotky č. 1114/13 (byt) ... v obci Praha, Břevnov",
  "categoryName": "Nebytový/kancelářský prostor",
  "tags": ["Byt"],
  "itemType": "real",
  "estimatedPrice": 996000,
  "reservePrice": 664000,
  "discountPct": 33.3,
  "priceAnomaly": false,
  "minimalBid": 1000,
  "cautionDeposit": 166000,
  "cautionAccountNumber": "5002209054/5500",
  "cautionAccountIban": "CZ6355000000005002209054",
  "cautionVariableSymbol": "0038025",
  "startAt": "2026-07-27T08:00:00.000+00:00",
  "endAt": "2026-07-27T08:30:00.000+00:00",
  "locationPrecision": "address",
  "countyName": "Praha",
  "cityName": "Praha",
  "municipalDistrict": "Praha 6",
  "street": "Slavníkova",
  "houseNumber": "1114",
  "latitude": 50.0844635,
  "longitude": 14.3652171,
  "ruianAdm": 22160744,
  "ruianCityCode": 554782,
  "executorNumber": "217",
  "executorName": "Tunkl Tomáš Mgr.",
  "executorEmail": "epodatelna@vasexekutor.cz",
  "hasAppraisal": true,
  "documents": [
    { "type": "auction_decree", "label": "Auction decree (dražební vyhláška)", "sizeBytes": 202324, "locked": false, "url": "https://www.portaldrazeb.cz/upload/auction-document/xMBvM" },
    { "type": "expert_report", "label": "Expert appraisal (odborný posudek)", "sizeBytes": 5938174, "locked": false, "url": "https://www.portaldrazeb.cz/upload/auction-document/5dvDX" }
  ],
  "jurisdiction": "CZ",
  "retrievedAt": "2026-07-27T09:14:02.118Z"
}
````

That row is also a good illustration of why `tags` and `title` are worth reading: the register filed
a flat under `Nebytový/kancelářský prostor`.

### What is `discountPct` and why is it the field to sort on?

Czech executors must publish both the **expert appraisal** of the property and the **reserve
price** at which bidding opens. The gap between them is the distressed discount, and it is the
reason this register is read at all.

`discountPct = (appraised - reserve) / appraised`, computed for you. A first auction typically
opens at two thirds of the appraisal; a lot that failed to sell is re-auctioned lower, which
`repeatedOrder` tells you.

A small number of rows - roughly 1% - carry a reserve **above** the appraisal, usually an obvious
typo in the source appraisal. Those come through with a negative discount and
`priceAnomaly: true`. The raw figures are passed on unaltered rather than clamped, so you can judge
them yourself instead of wondering why a feed looks wrong.

### How do I get just flats in one region?

```json
{
  "listings": ["upcoming"],
  "categories": ["13"],
  "counties": ["Jihomoravský kraj"],
  "minPrice": 500000,
  "maxPrice": 4000000
}
```

Categories are the register's own 18 ids - `"3"` land, `"7"` house, `"13"` flat, `"33"` vehicles,
`"39"` whole companies, and so on. The register's category filter is **hierarchical and over-broad**:
ask it for `13` (Byt) and it also hands back the parent `1 Nemovitosti` and the sibling
`15 Nebytový prostor`. This actor sends the filter anyway - it still narrows the query - and then
filters the result again to exactly the ids you picked. Set `exactCategories: false` if you would
rather have the register's broader interpretation.

The category tree is loose in the source too, so check `tags` and `title` as well as
`categoryName` when precision matters.

### Which list should I read?

| List | What it holds |
|---|---|
| `upcoming` | Everything scheduled. **The main one.** |
| `online` | The subset conducted online |
| `ongoing` | Auctions open for bidding at this second - **normally empty** |
| `finished` | A small rolling window of recently closed auctions |
| `preemption` | Lots in the předražek (pre-emption) window, where a higher offer can still be made |

`ongoing` being empty is a real answer, not a failure: Czech auctions run in short windows, so most
of the time nothing is live. The run exits green and says so.

### Can I research past sale prices?

**No, and no scraper of this register can.** `finished` is a rolling window of a couple of dozen
rows and date filters do not reach behind it - asking for 2020 onwards returns the same handful.
The register simply does not retain a public archive.

If you want a price history, build one: schedule this actor against `finished` and accumulate the
results into your own dataset. From the day you start it compounds, but the first run cannot give
you five years of comparables and nothing that claims to is reading this source.

### Will every auction be in my results?

That is the part this actor is built around.

The register's own paging is unstable - many auctions share a start time, ties come back in a
different order on each request, and walking through pages therefore returns some rows twice and
misses others entirely. Measured against the register's stated total of 731, naive paging returned
729, 721 and 727 on three consecutive attempts, losing a different handful each time and reporting
success every time.

So this actor does not page. It splits the date range into windows small enough that the register
returns each one whole in a single request, and then checks each window against the count the
register itself reports for it. If anything cannot be accounted for, the run says **"Partial:"**
with the exact shortfall instead of looking clean. Full nationwide sweeps reconcile at 731 of 731.

The same honesty applies at the end: hitting `maxResults` is stated in the status message, and rows
dropped by your own category or region filter are reported separately so a short result is never
mistaken for a thin register.

### How much does it cost?

Pay per auction record exported. Nothing else is charged.

- **Failed retrievals are not billed.** A row is only pushed once the register has actually returned
  it, so our breakage never appears on your bill.
- **Duplicates are not billed.** An online lot is also an upcoming lot; select both lists and it is
  still exported, and charged, once.
- **An empty result costs nothing** beyond the run start. A filter that matches nothing, or an empty
  `ongoing` list, is a legitimate answer.

There is no proxy cost, no captcha cost and no third-party key to pay for.

### Do the document links actually work?

Yes. `documents[].url` resolves to the real PDF. The auction decree (dražební vyhláška) and the
expert appraisal (odborný posudek) are published openly and download without a session - the
appraisal is where the valuation reasoning, floor plans and condition notes live.

The register gates a few document types behind an account, mostly post-auction resolutions. Those
are still listed, flagged `locked: true`, so you can see that a document exists rather than
silently receiving a shorter list. `hasAppraisal` tells you at a glance whether the valuation is
openly downloadable for that lot.

### Why do some rows have no address?

Because not everything sold at auction has one. Location comes in three grades and every record
says which one it has, in `locationPrecision`:

| `locationPrecision` | Meaning |
|---|---|
| `address` | Full RÚIAN address, coordinates usually present |
| `district` | Region and district only |
| `none` | No published location - typical for vehicles and movable property |

Check that field before filtering on coordinates, or you will quietly drop most of the register.
`ruianAdm` and `ruianCityCode` are official RÚIAN identifiers, so they join cleanly to Czech
cadastral and address datasets.

### Who is this for?

- **Property investors and buying agents** monitoring for lots that open well below appraisal in a
  target region.
- **Credit risk and collections teams** watching whether a debtor's assets have reached auction -
  the effect of an insolvency, where [ISIR](https://apify.com/regdata/czech-isir-insolvency-scraper)
  gives you the cause.
- **Valuers and market analysts** who want the appraisal PDFs and the appraised-vs-reserve spread.
- **Legal and compliance teams** tracking enforcement against a counterparty.

Set `mode: "auctioneers"` to get the directory of every Czech judicial executor office instead -
number, name, district, address, website - as its own small dataset.

### Is scraping this legal?

Portál dražeb is the register in which Czech judicial executors are **legally required** to publish
their auctions, precisely so that the public can find and bid on them. It is open to everyone, needs
no account, and this actor reads only what that public listing returns.

The records are about assets and enforcement proceedings. The named individuals are the executors -
public officials acting in their official capacity, whose details the register publishes by law.
Under GDPR that is a public official source, but you remain the controller of what you do with it
downstream, so use it for legitimate purposes.

This actor does not download the PDFs; it gives you the register's own links. It does not bid, and
it cannot - bidding needs a verified account, and nothing here touches it.

### How do I use it from code?

```bash
apify call YOUR_USERNAME/czech-drazby-auction-scraper \
  --input '{"listings":["upcoming"],"categories":["7","13"],"itemType":"real","maxResults":200}'
```

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/czech-drazby-auction-scraper').call({
    listings: ['upcoming'],
    categories: ['13'],
    counties: ['Praha'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const bargains = items.filter((i) => i.discountPct >= 40 && !i.priceAnomaly);
console.log(bargains.map((i) => [i.title, i.reservePrice, i.discountPct, i.url]));
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/czech-drazby-auction-scraper").call(
    run_input={"listings": ["upcoming"], "categories": ["3", "5"], "minPrice": 1000000}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["reservePrice"], item["discountPct"], item["cityName"])
```

Works with **n8n**, **Make**, **Zapier** and any HTTP client through the standard Apify API, and
with AI agents over MCP.

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `auctions` | `auctions`, or `auctioneers` for the executor-office directory |
| `listings` | array | `["upcoming"]` | `upcoming`, `online`, `ongoing`, `finished`, `preemption` |
| `startFrom` | string | today | Earliest auction start date, `YYYY-MM-DD` |
| `startTo` | string | +1 year | Latest auction start date, `YYYY-MM-DD` |
| `categories` | array | all | Register category ids as strings - `"3"` land, `"7"` house, `"13"` flat, `"33"` vehicles, `"39"` companies... |
| `itemType` | enum | `any` | `real` estate only, `movable` property only, or both |
| `counties` | array | all | Region names as the register spells them, e.g. `Moravskoslezský kraj` |
| `minPrice` / `maxPrice` | integer | - | Reserve price bounds in CZK, applied by the register |
| `maxResults` | integer | 1000 | Maximum auction records to export |
| `includeDetails` | boolean | `false` | Adds bid history, result and objections - one extra request per auction |
| `exactCategories` | boolean | `true` | Discard the parent and sibling categories the register adds on its own |

A narrower date range costs fewer requests and finishes sooner, because the range is what the run
splits its queries by.

### In what language is the data?

Czech, exactly as the register holds it - titles, descriptions, categories, region names. That is
the authoritative form, so it is returned rather than a guess at a translation. The field names,
the schema and the status messages are English, and every category and document type carries an
English label alongside the Czech one.

### Limitations

- **No sale-price history** - the register keeps no public archive (see above).
- **Bid history and results** come from the per-auction detail record and only when
  `includeDetails` is on. Upcoming lots have no bids yet, so leave it off unless you are reading
  finished ones.
- **Movable lots usually have no address**, so they cannot be mapped - `locationPrecision` says so.
- **The register's own categorisation is loose.** Exact matching is applied on top, but a
  mis-categorised lot at source stays mis-categorised.
- **No sorting.** The register accepts a sort parameter and ignores it, so this actor does not offer
  a control that would do nothing.
- **This is a precision product, not a bulk one.** A nationwide upcoming sweep is in the hundreds of
  auctions, not the millions. It is built for monitoring a filter, not for hoarding a market.

### Related actors

Part of a suite of official government registry actors - **no public API to build or maintain**, pay per result, nothing to configure.

| Country | Actors |
|---|---|
| Poland | [BDO](https://apify.com/regdata/bdo-waste-registry-scraper) · [CRBR](https://apify.com/regdata/crbr-beneficial-owners-scraper) · [KRS (financials)](https://apify.com/regdata/poland-krs-financial-scraper) · [EKW](https://apify.com/regdata/ekw-ksiegi-wieczyste-scraper) · [KNF](https://apify.com/regdata/knf-registry-scraper) · [KRS (board)](https://apify.com/regdata/krs-fullnames-scraper) · [KRZ](https://apify.com/regdata/krz-debtor-scraper) · [MSiG](https://apify.com/regdata/msig-scraper) · [KYB check](https://apify.com/regdata/poland-kyb-check) · [PEP (Sejm)](https://apify.com/regdata/poland-parliamentary-pep-scraper) · [REGON (sites)](https://apify.com/regdata/polish-premises-prospector) · [REGON](https://apify.com/regdata/polish-regon-scraper) · [UOKiK](https://apify.com/regdata/uokik-clauses-scraper) |
| Germany | [Insolvenzbekanntmachungen](https://apify.com/regdata/germany-insolvency-scraper) · [Handelsregister](https://apify.com/regdata/germany-handelsregister-scraper) |
| Spain | [BORME](https://apify.com/regdata/borme-corporate-acts-scraper) · [Registro Mercantil](https://apify.com/regdata/spain-company-directory-scraper) · [Registro Público Concursal](https://apify.com/regdata/spain-concursal-scraper) |
| Italy | [INI-PEC](https://apify.com/regdata/italy-pec-lookup) · [Registro Imprese](https://apify.com/regdata/italy-registro-imprese-scraper) |
| Austria | [Ediktsdatei](https://apify.com/regdata/austria-ediktsdatei-scraper) · [WKO](https://apify.com/regdata/wko-business-directory-scraper) |
| France | [Societe.com](https://apify.com/regdata/societe-com-scraper) |
| Belgium | [KBO / BCE](https://apify.com/regdata/belgium-kbo-company-scraper) |
| Czechia | [ISIR](https://apify.com/regdata/czech-isir-insolvency-scraper) · **Portál dražeb (this actor)** |
| Slovakia | [RPVS](https://apify.com/regdata/slovakia-rpvs-ubo-scraper) |
| Cyprus | [DRCOR](https://apify.com/regdata/cyprus-drcor-company-scraper) |
| Ireland | [CRO](https://apify.com/regdata/ireland-cro-company-scraper) |
| Portugal | [Publicações MJ](https://apify.com/regdata/portugal-corporate-acts-scraper) |
| Nigeria | [CAC](https://apify.com/regdata/nigeria-cac-company-scraper) |
| Colombia | [RUES](https://apify.com/regdata/colombia-rues-company-scraper) |
| USA | [California SoS](https://apify.com/regdata/california-sos-business-scraper) · [California UCC](https://apify.com/regdata/california-ucc-lien-scraper) |
| UAE | [ADGM](https://apify.com/regdata/uae-adgm-public-register-scraper) |
| Global | [Adverse media](https://apify.com/regdata/adverse-media-screener) |

**Natural pairing for Czechia:** [ISIR](https://apify.com/regdata/czech-isir-insolvency-scraper)
tells you a debtor went insolvent; this actor tells you their assets have reached auction, with the
appraisal, the reserve and the date.

***

**Data source:** [Portál dražeb](https://www.portaldrazeb.cz/drazby/) - the register of auctions of
Czech judicial executors. This actor is not affiliated with or endorsed by the register or the
Chamber of Executors.

> Full suite: [apify.com/regdata](https://apify.com/regdata) · Callable from any MCP client via [mcp.apify.com](https://mcp.apify.com)

# Actor input Schema

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

'Auctions' enumerates auction listings. 'Executor offices' instead exports the directory of all Czech judicial executor offices with their addresses and contact details, and ignores every filter below.

## `listings` (type: `array`):

Which of the register's lists to read. 'Upcoming' is the main one. 'Ongoing' is empty most of the time because auctions run in short windows - that is a normal result, not an error. 'Finished' and 'Pre-emption' are small rolling windows: the register does NOT keep a historical archive, so they cannot be used to research past sale prices.

## `startFrom` (type: `string`):

Earliest auction start date, YYYY-MM-DD. Defaults to today for forward-looking lists. This also drives how the run splits its queries, so a narrower window costs fewer calls.

## `startTo` (type: `string`):

Latest auction start date, YYYY-MM-DD. Defaults to one year ahead. The register typically holds about four months of scheduled auctions.

## `categories` (type: `array`):

Restrict to these property categories. The register's own category filter is hierarchical and over-broad - asking for 'Byt' also returns its parent 'Nemovitosti' and its sibling 'Nebytový prostor' - so results are filtered again locally to exactly what you picked. Turn off 'Exact category match' below if you want the register's broader interpretation.

## `itemType` (type: `string`):

Keep only real estate, only movable property, or both. Movable lots (vehicles, machinery, goods) usually have no address, so they cannot be placed on a map.

## `counties` (type: `array`):

Keep only auctions whose property lies in these regions, matched on the region name as the register spells it, e.g. 'Praha', 'Jihočeský kraj', 'Moravskoslezský kraj'. Partial matches count. Lots with no published location are excluded when this is set.

## `minPrice` (type: `integer`):

Lowest reserve (starting) price to include, in CZK. Applied by the register itself.

## `maxPrice` (type: `integer`):

Highest reserve (starting) price to include, in CZK. Applied by the register itself.

## `maxResults` (type: `integer`):

Maximum auction records to export. A lot appearing in more than one selected list is exported once, so you are never charged twice for the same auction.

## `includeDetails` (type: `boolean`):

Fetch each auction's detail record to add bid history, result and objections. Costs one extra request per auction, so it roughly doubles a run's duration. Upcoming auctions have no bids yet, so leave this off unless you are reading finished lots.

## `exactCategories` (type: `boolean`):

On by default. Keeps only the categories you selected, discarding the parent and sibling categories the register adds on its own. Turn off to receive the register's broader match.

## Actor input object example

```json
{
  "mode": "auctions",
  "listings": [
    "upcoming"
  ],
  "itemType": "any",
  "maxResults": 100,
  "includeDetails": false,
  "exactCategories": true
}
```

# Actor output Schema

## `auctions` (type: `string`):

Auction records with pricing, property location and document links in the default dataset.

# 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 = {
    "listings": [
        "upcoming"
    ],
    "startFrom": "",
    "startTo": "",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("regdata/czech-drazby-auction-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 = {
    "listings": ["upcoming"],
    "startFrom": "",
    "startTo": "",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("regdata/czech-drazby-auction-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 '{
  "listings": [
    "upcoming"
  ],
  "startFrom": "",
  "startTo": "",
  "maxResults": 100
}' |
apify call regdata/czech-drazby-auction-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Czech Public Auctions Scraper - Portál dražeb",
        "description": "Track every auction run by Czech judicial executors: foreclosed flats, houses, land, vehicles and whole companies with the appraised value, the reserve price and the discount between them, the deposit, the property address with coordinates and the published appraisal PDF.",
        "version": "1.0",
        "x-build-id": "EYk2qWIBBdduvHDb9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/regdata~czech-drazby-auction-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-regdata-czech-drazby-auction-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/regdata~czech-drazby-auction-scraper/runs": {
            "post": {
                "operationId": "runs-sync-regdata-czech-drazby-auction-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/regdata~czech-drazby-auction-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-regdata-czech-drazby-auction-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": {
                    "mode": {
                        "title": "What to export",
                        "enum": [
                            "auctions",
                            "auctioneers"
                        ],
                        "type": "string",
                        "description": "'Auctions' enumerates auction listings. 'Executor offices' instead exports the directory of all Czech judicial executor offices with their addresses and contact details, and ignores every filter below.",
                        "default": "auctions"
                    },
                    "listings": {
                        "title": "Auction lists",
                        "type": "array",
                        "description": "Which of the register's lists to read. 'Upcoming' is the main one. 'Ongoing' is empty most of the time because auctions run in short windows - that is a normal result, not an error. 'Finished' and 'Pre-emption' are small rolling windows: the register does NOT keep a historical archive, so they cannot be used to research past sale prices.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "upcoming",
                                "online",
                                "ongoing",
                                "finished",
                                "preemption"
                            ],
                            "enumTitles": [
                                "Upcoming (připravované)",
                                "Online only (online)",
                                "Ongoing right now (probíhající)",
                                "Recently finished (ukončené)",
                                "Pre-emption window (předražky)"
                            ]
                        },
                        "default": [
                            "upcoming"
                        ]
                    },
                    "startFrom": {
                        "title": "Auction date from",
                        "type": "string",
                        "description": "Earliest auction start date, YYYY-MM-DD. Defaults to today for forward-looking lists. This also drives how the run splits its queries, so a narrower window costs fewer calls."
                    },
                    "startTo": {
                        "title": "Auction date to",
                        "type": "string",
                        "description": "Latest auction start date, YYYY-MM-DD. Defaults to one year ahead. The register typically holds about four months of scheduled auctions."
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Restrict to these property categories. The register's own category filter is hierarchical and over-broad - asking for 'Byt' also returns its parent 'Nemovitosti' and its sibling 'Nebytový prostor' - so results are filtered again locally to exactly what you picked. Turn off 'Exact category match' below if you want the register's broader interpretation.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "3",
                                "5",
                                "7",
                                "9",
                                "13",
                                "15",
                                "17",
                                "19",
                                "25",
                                "29",
                                "31",
                                "33",
                                "35",
                                "37",
                                "39",
                                "41",
                                "43"
                            ],
                            "enumTitles": [
                                "Nemovitosti - real estate (all)",
                                "Pozemek - land",
                                "Stavební pozemek - building plot",
                                "Rodinný dům - house",
                                "Rekreační objekt - recreational property",
                                "Byt - flat",
                                "Nebytový/kancelářský prostor - commercial/office",
                                "Průmyslová stavba - industrial building",
                                "Zemědělská stavba - agricultural building",
                                "Movitosti - movable property (all)",
                                "Bílá technika - appliances",
                                "Nábytek - furniture",
                                "Auto-moto - vehicles",
                                "Starožitnosti a umění - antiques and art",
                                "Ostatní movitost - other movable",
                                "Firmy - companies",
                                "Garáž - garage",
                                "Ostatní nemovitost - other real estate"
                            ]
                        }
                    },
                    "itemType": {
                        "title": "Property type",
                        "enum": [
                            "any",
                            "real",
                            "movable"
                        ],
                        "type": "string",
                        "description": "Keep only real estate, only movable property, or both. Movable lots (vehicles, machinery, goods) usually have no address, so they cannot be placed on a map.",
                        "default": "any"
                    },
                    "counties": {
                        "title": "Regions (kraje)",
                        "type": "array",
                        "description": "Keep only auctions whose property lies in these regions, matched on the region name as the register spells it, e.g. 'Praha', 'Jihočeský kraj', 'Moravskoslezský kraj'. Partial matches count. Lots with no published location are excluded when this is set.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum reserve price (CZK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest reserve (starting) price to include, in CZK. Applied by the register itself."
                    },
                    "maxPrice": {
                        "title": "Maximum reserve price (CZK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest reserve (starting) price to include, in CZK. Applied by the register itself."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum auction records to export. A lot appearing in more than one selected list is exported once, so you are never charged twice for the same auction.",
                        "default": 1000
                    },
                    "includeDetails": {
                        "title": "Include bid history and outcome",
                        "type": "boolean",
                        "description": "Fetch each auction's detail record to add bid history, result and objections. Costs one extra request per auction, so it roughly doubles a run's duration. Upcoming auctions have no bids yet, so leave this off unless you are reading finished lots.",
                        "default": false
                    },
                    "exactCategories": {
                        "title": "Exact category match",
                        "type": "boolean",
                        "description": "On by default. Keeps only the categories you selected, discarding the parent and sibling categories the register adds on its own. Turn off to receive the register's broader match.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
