# Czech Auctions Scraper - Portál dražeb (portaldrazeb.cz) (`rel8ble/portal-drazeb-scraper`) Actor

Scrape Czech public auctions from portaldrazeb.cz: flats, houses, land, cars and more with appraisal price, minimum bid, deposit, date, region, address, GPS, photos and documents. Filter by category, location, price and date. English + Czech fields. HTTP-only, fast.

- **URL**: https://apify.com/rel8ble/portal-drazeb-scraper.md
- **Developed by:** [Giovanni Rich](https://apify.com/rel8ble) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Czech Auctions Scraper - Portál dražeb (portaldrazeb.cz) Property and Vehicle Auctions

**Portál dražeb Scraper** is a Czech auctions scraper and portaldrazeb.cz API: export every public auction (flats, family houses, land, commercial property, cars and other assets) with appraisal price, minimum bid, deposit, auction date, region, address, GPS coordinates, photos and official documents, as JSON, CSV or Excel.

Portál dražeb is the official auction portal of the Czech Chamber of Executors (Exekutorská komora ČR) and the largest source of execution auctions in Czechia. The site has no export and no public data API. This actor reads the same data the site's listing pages load, over plain HTTP with **no browser and no login**, and adds English category names and handy extras like the minimum bid as a % of the appraisal.

### How to use

1. Pick the **Auction lists** you want (upcoming is the main one; also ongoing, finished with final prices, and overbid rounds).
2. Optionally filter by **Categories** (flats, houses, land, vehicles, ...), **Locations** (`Praha`, `Brno`, `Jihomoravský`, ...), **price** range, **auction date** range or **keywords** (`3+1`, `garáž`, `Škoda`).
3. Click **Start**. The whole portal (~800 auctions) is scraped in about a minute.
4. Download the data as JSON, CSV, Excel or HTML, or connect it to Google Sheets, Make, Zapier or n8n.

### What you get

- **Prices (CZK)**: appraisal price (odhadní cena), minimum bid (nejnižší podání), minimum bid as % of appraisal, bid increment, caution deposit (jistota), and the current or final price for running and finished auctions.
- **Timing**: auction start and end, publication date, days until the auction, whether it's an online (electronic) auction, and whether it's a repeated auction.
- **Location**: region (kraj), district (okres), city, street address when published, and latitude/longitude for ~96% of auctions.
- **Asset**: title, Czech and English category, full description, and photo URLs.
- **Documents**: direct links to the auction decree (dražební vyhláška), expert valuation report (znalecký posudek) and other official PDFs, labeled by type.
- **Auctioneer**: the executor's office name, number, district, website and official contact details.
- **IDs**: auction ID, official file number (e.g. `098EX01347/21-292`) and the auction page URL, so you can track the same auction across runs.

### Use cases

- Real-estate investors: a daily feed of flats and houses below appraisal, filtered by region and price
- Car dealers and flippers: vehicle auctions with minimum bids and dates
- Market research on Czech execution auctions: volumes, discounts to appraisal, regional spread
- Alerts: schedule a daily run with your filters and get new auctions in Slack, email or a spreadsheet
- Proptech apps and listing aggregators that need Czech auction inventory

### Input example

| Field | Default | Description |
|---|---|---|
| `listings` | `["upcoming"]` | `upcoming`, `ongoing`, `finished`, `overbids` |
| `categories` | all | `realEstate`, `land`, `house`, `flat`, `recreational`, `apartmentBuilding`, `commercial`, `garage`, `otherRealEstate`, `movables`, `vehicles`, `electronics`, `furniture`, `art`, `otherMovables`, `intangible` |
| `locations` | all | Region, district, city or street text, e.g. `Praha`, `Brno`, `Plzen` (accents optional) |
| `minPrice` / `maxPrice` | - | Minimum-bid range in CZK |
| `startFrom` / `startTo` | - | Auction date range, `YYYY-MM-DD` |
| `keywords` | - | Words in the title or description |
| `electronicOnly` | false | Only auctions you can bid on online |
| `maxResults` | 0 (no limit) | Cap on saved auctions |

Example:

```json
{
    "listings": ["upcoming", "finished"],
    "categories": ["flat", "house"],
    "locations": ["Praha", "Brno", "Plzen"],
    "minPrice": 1000000
}
```

### Output example

One dataset item per auction. This is a real record from a test run (upcoming flat auction in Prague; description shortened):

```json
{
    "listing": "upcoming",
    "auctionId": "poJ7z",
    "auctionNumber": "098EX01347/21-292",
    "url": "https://www.portaldrazeb.cz/drazba/098ex01347-21-292-poj7z",
    "title": "Byt v Praze - Krč o výměře 76,6 m2",
    "category": "Byt",
    "categoryEn": "Flat / apartment",
    "itemType": "real",
    "auctionType": "execution",
    "electronic": true,
    "status": "upcoming",
    "startAt": "2026-10-06T08:00:00.000+00:00",
    "endAt": "2026-10-06T11:00:00.000+00:00",
    "daysToStart": 11,
    "currency": "CZK",
    "estimatedPrice": 9150000,
    "minimumBid": 6100000,
    "minimumBidPctOfEstimate": 66.7,
    "bidIncrement": 15000,
    "cautionDeposit": 1300000,
    "region": "Hlavní město Praha",
    "district": "Praha",
    "city": "Praha",
    "address": "Za dvorem 1862/3, Krč, Praha",
    "latitude": 50.0183617,
    "longitude": 14.4627307,
    "description": "Předmětem dražby je byt v Praze - Krč o výměře 76,6 m2 s lodžií 6,6 m2 a sklepní kójí ...",
    "images": ["https://www.portaldrazeb.cz/upload/auction-image/32vlN"],
    "documents": [
        { "type": "expert_report", "typeLabel": "Expert valuation report (znalecký posudek)", "url": "https://www.portaldrazeb.cz/upload/auction-document/16YPG" },
        { "type": "auction_decree", "typeLabel": "Auction decree (dražební vyhláška)", "url": "https://www.portaldrazeb.cz/upload/auction-document/NxZnn" }
    ],
    "auctioneerOffice": { "name": "Usnul Milan JUDr.", "officeNumber": "098", "district": "Praha 9", "website": "http://www.ep9.cz" },
    "scrapedAt": "2026-09-25T05:31:26.675Z"
}
```

The dataset's **Overview** view shows photos, title, category, date, appraisal, minimum bid, % of appraisal, deposit, region, city, address and the auction link.

#### Field fill rates (real test run: all 818 upcoming + finished auctions)

| Field | Fill rate |
|---|---|
| ID, file number, URL, title, category, status, start date, appraisal, minimum bid, description, documents | 100% |
| region, district, city | 97-98% |
| latitude / longitude | 96% |
| photos | 81% |
| auction end time, caution deposit | 70% |
| street address | 34% (many executors publish only the municipality) |
| bid increment | 20% (set for online auctions) |
| current / final price | set for running and finished auctions |

### Pricing

Pay per result: **$3.00 per 1,000 results** (one result = one auction saved to the dataset).

- Every upcoming auction in Czechia (~800) = about **$2.40**
- A daily alert for flats and houses in Prague (~5-15 new matches) = a few cents per day
- 100 auctions = $0.30

Filters are applied before saving, so you only pay for auctions that match. You're never charged for failed requests or duplicates. Apify's free plan includes $5 of monthly platform credit.

### Integrations

- **Make, Zapier and n8n**: send new auctions to Slack, email, a CRM or Airtable.
- **Google Sheets**: export straight into a spreadsheet, or refresh it on a schedule.
- **Apify API**: run the actor and fetch results over REST, or with the official JavaScript and Python clients.
- **Webhooks**: react the moment a run finishes.
- **Schedules**: run daily with your filters; use `auctionId` to spot the auctions you haven't seen yet.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can search Czech auctions with this actor.

### Limits

- **Portál dražeb only.** Auctions published only on other Czech portals (e.g. voluntary-auction or insolvency sites) aren't included.
- **Descriptions are in Czech**, exactly as the executor wrote them. Categories are translated to English.
- **Street addresses are optional** for executors; 34% of auctions have one, but region/district/city and coordinates are nearly always there.
- **Documents are links**, not parsed text. File names aren't included because uploaded file names sometimes contain the debtor's name.
- **Finished list is short-lived.** The portal lists recently finished auctions only; schedule runs if you want a history of final prices.
- The actor only collects public listing data. Bidding requires a verified account on the portal, and this actor doesn't do that.

### FAQ

**Is it legal to scrape Portál dražeb?**
The actor collects public auction notices that executors are legally required to publish, and it doesn't log in. Auction listings describe assets, not people: the actor leaves out the portal's personal fields (responsible-person details and document file names) and returns only the executor office's official contact data. You're responsible for how you use the data under GDPR and Czech law. This is not legal advice.

**How does it avoid blocks?**
Each run makes only a few requests: one page load per list, plus a few paged API calls. They go through Apify Proxy with realistic Chrome headers and a session pool. If a request fails or is refused, the session is retired and retried on a fresh one with exponential backoff (6 retries by default).

**How fresh is the data?**
It's live: every run reads the portal at that moment. Auction dates, prices and statuses are exactly what the portal shows.

**Why are some auctions a "1/2" share of a house?**
Executors often auction co-ownership shares (spoluvlastnický podíl). The title says so; check the auction decree for details.

**Can I get only new auctions every day?**
Schedule the actor daily and keep the `auctionId`s you've already seen (for example in a Google Sheet or a key-value store). Anything with a new ID is new.

### How it works (for developers)

The listing pages on portaldrazeb.cz are a Vue app that loads auctions from the site's own JSON endpoint (`PUT /drazby/{list}.json`) with a CSRF token issued with the page. The actor loads the page once per list for a token and session cookie, pages through the JSON in blocks of 200, normalises every record (prices, RÚIAN address, region, coordinates, photos, documents), applies your filters, and pushes one result per matching auction. It uses Crawlee's `HttpCrawler` with a session pool and retries.

```bash
npm install
npm test                                  # parser tests
APIFY_LOCAL_STORAGE_DIR=./storage node src/main.js   # input in storage/key_value_stores/default/INPUT.json
```

# Actor input Schema

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

Optional. Auction lists to scrape, list of: "upcoming" (scheduled, main list, ~700-900; default), "ongoing" (running now), "finished" (recently ended, with final price), "overbids" (in the overbid window). Default \["upcoming"].

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

Optional. Only these asset types, list of: "realEstate" (all), "land", "house", "flat", "recreational", "apartmentBuilding", "commercial", "garage", "otherRealEstate", "movables" (all), "vehicles", "electronics", "furniture", "art", "otherMovables", "intangible". Omit for all.

## `locations` (type: `array`):

Optional. Only auctions whose region (kraj), district (okres), city or address contains one of these strings, e.g. \["Praha", "Brno", "Jihomoravsky"]. Accents optional. Omit for all of Czechia.

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

Optional. Minimum of the minimum bid (nejnizsi podani) in CZK, integer >= 0, e.g. 500000.

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

Optional. Maximum of the minimum bid in CZK, integer >= 0, e.g. 3000000.

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

Optional. Only auctions starting on or after this date, format YYYY-MM-DD.

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

Optional. Only auctions starting on or before this date, format YYYY-MM-DD.

## `keywords` (type: `array`):

Optional. Only auctions whose title or description contains one of these words, e.g. \["3+1", "garaz", "Skoda"]. Accents optional.

## `electronicOnly` (type: `boolean`):

Optional boolean. true = only auctions you can bid on online through the portal. Default false.

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

Optional. Maximum auctions saved in total, integer >= 0. Default 0 = no limit. Use 10-20 for a quick answer.

## `maxRequestRetries` (type: `integer`):

Optional, advanced. Retries per failed or blocked request, integer 0-20; each retry uses a new proxy session. Default 6. Leave unset.

## `proxyConfiguration` (type: `object`):

Optional, advanced. Apify Proxy settings object, e.g. {"useApifyProxy": true}. Default: Apify Proxy on (datacenter). Leave unset; switch to {"useApifyProxy": true, "apifyProxyGroups": \["RESIDENTIAL"]} only if the run log shows repeated blocks.

## Actor input object example

```json
{
  "listings": [
    "upcoming"
  ],
  "categories": [
    "flat",
    "house"
  ],
  "electronicOnly": false,
  "maxResults": 20,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All auctions matching your filters, with prices, dates, location, photos and documents.

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

Auctions on the portal vs. matched vs. saved, per list.

# 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"
    ],
    "categories": [
        "flat",
        "house"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/portal-drazeb-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"],
    "categories": [
        "flat",
        "house",
    ],
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/portal-drazeb-scraper").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 '{
  "listings": [
    "upcoming"
  ],
  "categories": [
    "flat",
    "house"
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rel8ble/portal-drazeb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rel8ble/portal-drazeb-scraper"
        }
    }
}
```

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/0FL8Vl3j7Iia6zPvh/builds/D518WNsrwhK2bCw4z/openapi.json