# Sreality.cz Real Estate Scraper (`solidcode/sreality-cz-scraper`) Actor

\[💰 $3.8 / 1K] Extract real estate listings from Sreality.cz, the largest Czech property portal. Search apartments, houses, land, and commercial properties for sale, rent, or auction by city or region. Get prices, GPS coordinates, room layouts, area, photos, agency contacts, and full descriptions.

- **URL**: https://apify.com/solidcode/sreality-cz-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.80 / 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

## Sreality.cz Real Estate Scraper

Pull property listings from Sreality.cz — the largest Czech real-estate portal — at scale, complete with price in CZK, GPS coordinates, Czech room dispositions (2+kk, 3+1), usable area, energy class, ownership type, six amenity flags, agency name, and the full photo set for every apartment, house, plot, and commercial space for sale, rent, or auction. Built for property investors, estate agencies, and relocation researchers who need fresh, structured Czech listing data across all of Czechia without copying it card by card.

### Why This Scraper?

- **Five property categories across three deal types** — apartments, houses, land, commercial, and other, each available for sale, for rent, or in auction. One actor covers the entire Sreality catalogue.
- **Precise GPS on every listing** — exact latitude and longitude per property, ready to plot on a map or feed into a radius search without geocoding addresses yourself.
- **Six amenity flags per property** — `hasBalcony`, `hasElevator`, `hasParking`, `hasGarage`, `hasCellar`, and `isFurnished` come back as clean booleans you can filter on downstream — no need to read Czech descriptions to find a flat with parking.
- **Czech energy-efficiency class A–G** — the official energy rating (e.g. `"D - Méně úsporná"`, carrying the A–G class letter plus its Czech label) is extracted for every detail-enriched listing, alongside ownership type (personal / cooperative) and building material (brick / panel).
- **Native Czech room dispositions preserved** — layout tokens like `2+kk`, `3+1`, and `4+kk` are kept verbatim, exactly as Czech buyers and agents search for them.
- **Diacritics-tolerant search across all 14 Czech regions** — type "Praha", "Brno", "Ostrava", or a whole region like "Jihomoravský kraj"; "Plzen" matches "Plzeň" too, so a missing accent never costs you results.
- **Full Czech description text plus agency name** — the complete listing write-up and the selling agency or private-seller name on every property, ready for lead lists or NLP.
- **Paste a URL or search by filter** — drop in any Sreality.cz search-results or single-listing link and its deal type, property type, location, and price/area limits carry over, or type city names and set price/area bounds yourself.
- **Up to 50,000 results per run** — set `maxResults` to 0 for everything available in your search, with smooth pagination and no duplicates.

### Use Cases

**Real-Estate Investment & Analysis**
- Compare price per square metre across Prague districts and regional cities
- Track auction listings for below-market acquisition opportunities
- Filter by ownership type to separate personal-ownership flats from cooperatives
- Build comparables sets by disposition (`2+kk`, `3+1`) and usable area

**Lead Generation for Agencies**
- Build contact lists of selling agencies active in a target city
- Spot fresh listings the moment they appear in a region
- Identify private-seller listings to approach for representation
- Map competitor inventory by agency name and locality

**Market & Price Research**
- Measure average rent vs. sale price by city and district
- Quantify how energy class A–G correlates with asking price
- Chart inventory volume across all 14 Czech regions
- Analyse which amenities (balcony, parking, elevator) command a premium

**Relocation & Property Search**
- Shortlist apartments within a price and area band in a chosen city
- Pull GPS coordinates to map every option against schools or workplaces
- Filter for furnished rentals with an elevator and parking
- Compare neighbouring districts side by side in one dataset

**Data Enrichment & Integration**
- Enrich an existing Czech property database with current pricing and photos
- Feed live listings into analytics dashboards and valuation models
- Power alerting tools that flag new listings or price changes
- Translate full Czech descriptions for cross-border investor reports

### Getting Started

#### Search a City

The simplest run — apartments for sale in Prague:

```json
{
    "searchLocations": ["Praha"],
    "maxResults": 50
}
````

#### Filtered Search (Rent + Price + Area)

Furnished-friendly rental hunt in Brno within a budget and size band:

```json
{
    "searchLocations": ["Brno"],
    "dealType": "rent",
    "propertyType": "apartments",
    "minPrice": 15000,
    "maxPrice": 30000,
    "minArea": 50,
    "maxArea": 90,
    "maxResults": 200
}
```

#### Multi-City + URL, Full Detail

Mix several cities with a ready-made Sreality.cz search link and enrich every listing:

```json
{
    "searchLocations": ["Praha", "Ostrava", "Plzeň"],
    "startUrls": [
        "https://www.sreality.cz/hledani/prodej/domy/jihomoravsky-kraj"
    ],
    "dealType": "sale",
    "propertyType": "houses",
    "minPrice": 3000000,
    "maxResults": 1000,
    "includeDetails": true
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Sreality.cz URLs — either a search-results page (with filters already applied in the browser) or a single property page. Deal type, property type, location, and the price/area limits in the URL are carried over automatically; the run log lists exactly which filters were applied. The filters below do not apply to URLs. |
| `searchLocations` | string\[] | `["Praha"]` | Czech city or region names to search, e.g. "Praha", "Brno", "Ostrava", or a region like "Jihomoravský kraj". Diacritics are optional ("Plzen" works). Add several to scrape multiple places in one run. |

#### Search Filters

These apply only to `searchLocations`. When you use a URL, every filter comes from the URL itself.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dealType` | select | `For Sale` | Whether to find properties For Sale, For Rent, or in Auction. |
| `propertyType` | select | `Apartments` | The kind of property: Apartments, Houses, Land, Commercial, or Other. |
| `minPrice` | integer | null | Only include properties priced at or above this amount, in CZK. |
| `maxPrice` | integer | null | Only include properties priced at or below this amount, in CZK. |
| `minArea` | integer | null | Only include properties with at least this usable area, in m². |
| `maxArea` | integer | null | Only include properties with at most this usable area, in m². |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to return across all URLs and searches. Set to 0 for unlimited (up to a 50,000 safety cap). Start with 10–50 to test, then increase. |
| `includeDetails` | boolean | `true` | Open each listing for richer data: full description, building material, condition, ownership type, floor, energy class, the six amenity flags, and the complete photo set. Slower but much more detailed. When off, only search-result fields are returned. |

### Output

Each result is one property listing. Here is a representative row with full details enabled:

```json
{
    "listingId": "885764172",
    "url": "https://www.sreality.cz/detail/prodej/byt/3+kk/praha-vinohrady/885764172",
    "title": "Prodej bytu 3+kk 75 m²",
    "dealType": "sale",
    "propertyType": "apartments",
    "rooms": "3+kk",
    "locality": "Vinohrady, Praha 2",
    "city": "Praha 2",
    "district": "Praha 2 - Vinohrady",
    "latitude": 50.0755,
    "longitude": 14.4378,
    "price": 12500000,
    "priceUnit": "total",
    "currency": "CZK",
    "areaSqm": 75,
    "images": [
        "https://d18-a.sdn.cz/d_18/c_img_QO_b/abc123.jpeg"
    ],
    "agencyName": "RE/MAX Praha",
    "hasBalcony": true,
    "hasElevator": true,
    "hasParking": false,
    "hasGarage": false,
    "hasCellar": true,
    "isFurnished": false,
    "floor": "3. podlaží",
    "buildingType": "Cihlová",
    "condition": "Velmi dobrý stav",
    "ownership": "Osobní",
    "energyRating": "D - Méně úsporná",
    "description": "Nabízíme k prodeji světlý byt 3+kk o výměře 75 m² v žádané lokalitě Vinohrady...",
    "scrapedAt": "2026-06-02T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Sreality.cz property identifier |
| `url` | string | Direct link to the listing |
| `title` | string | Listing headline (e.g. "Prodej bytu 3+kk 75 m²") |
| `dealType` | string | `sale`, `rent`, or `auction` |
| `propertyType` | string | `apartments`, `houses`, `land`, `commercial`, or `other` |
| `rooms` | string | Czech room disposition (`2+kk`, `3+1`, …) |
| `agencyName` | string | Selling agency or private-seller name |
| `description` | string | Full Czech listing description (detail only) |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `locality` | string | Full locality string with district |
| `city` | string | City (e.g. "Praha 2") |
| `district` | string | District or region |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |

#### Pricing & Size

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in CZK (`null` when listed as "info on request") |
| `priceUnit` | string | `total` for sales, `per month` for rentals |
| `currency` | string | Always `CZK` |
| `areaSqm` | number | Usable or built area in m² |
| `images` | string\[] | Photo URLs (full set when `includeDetails` is on) |

#### Amenities

All six are clean booleans, populated when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `hasBalcony` | boolean | Property has a balcony |
| `hasElevator` | boolean | Building has an elevator |
| `hasParking` | boolean | Parking is available |
| `hasGarage` | boolean | Property includes a garage |
| `hasCellar` | boolean | Property includes a cellar |
| `isFurnished` | boolean | Property is furnished |

#### Building Details

Populated when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `floor` | string | Floor information |
| `buildingType` | string | Building material (brick, panel, …) |
| `condition` | string | Condition (new, very good, to renovate, …) |
| `ownership` | string | Ownership type (personal, cooperative, …) |
| `energyRating` | string | Energy-efficiency class label, e.g. `"D - Méně úsporná"` (class letter A–G plus its Czech description). `null` when the seller didn't set one. |

### Tips for Best Results

- **Start small** — set `maxResults` to 10–50 on your first run to confirm the data matches your needs, then scale up to a full city or region.
- **Skip the accents** — diacritics are optional. "Plzen" finds the same listings as "Plzeň" and "Ricany" matches "Říčany", so you never lose results to a missing Czech accent.
- **Search Czech dispositions, not bedroom counts** — Sreality uses `2+kk`, `3+1`, and similar tokens rather than "2-bed". The `rooms` field returns these verbatim, so filter on `2+kk` (kitchen corner) vs `2+1` (separate kitchen) the way local buyers do.
- **Toggle detail for speed vs. depth** — turn `includeDetails` off for a fast pass when you only need price, locality, and GPS; turn it on for energy class, ownership, amenities, and full descriptions.
- **Let URLs carry your search filters** — if you have built a search on Sreality.cz, paste that URL into `startUrls` and its deal type, property type, location, and price/area limits transfer automatically. The run log names exactly which filters were applied, so you always know what took effect.
- **Combine cities in one run** — list several `searchLocations` together to compare markets in a single dataset instead of running the actor once per city.
- **Use auction mode for deals** — set `dealType` to Auction to surface court and bankruptcy sales that rarely appear in standard searches.

### Pricing

**From $3.80 per 1,000 results** — flat pay-per-result, undercutting the going rate for Czech property data. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.46 | $0.43 | $0.41 | $0.38 |
| 1,000 | $4.55 | $4.30 | $4.05 | $3.80 |
| 10,000 | $45.50 | $43.00 | $40.50 | $38.00 |
| 100,000 | $455.00 | $430.00 | $405.00 | $380.00 |

A "result" is any property row in the output dataset. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate real-estate research, market analysis, and lead generation. You are responsible for complying with applicable laws and Sreality.cz's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data (such as seller or agency contact details) in line with GDPR and local privacy regulations.

# Actor input Schema

## `startUrls` (type: `array`):

Paste Sreality.cz URLs directly — either a search-results page (with your filters already applied in the browser) or a single property page. Any filters in the URL are kept automatically. The Deal Type, Property Type, and price/area settings below do NOT apply to URLs — those come from the URL itself.

## `searchLocations` (type: `array`):

Type Czech city or region names to search, e.g. 'Praha', 'Brno', 'Ostrava', or a whole region like 'Jihomoravský kraj'. Diacritics are optional ('Plzen' also works). Add several to scrape multiple places in one run. Leave empty if you are using URLs above.

## `dealType` (type: `string`):

Whether to find properties for sale, for rent, or in auction. Only applies to Search Locations — ignored when using URLs (the URL sets its own deal type).

## `propertyType` (type: `string`):

The kind of property to find. Only applies to Search Locations — ignored when using URLs.

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

Only include properties priced at or above this amount, in Czech koruna (CZK). Leave empty for no lower limit.

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

Only include properties priced at or below this amount, in Czech koruna (CZK). Leave empty for no upper limit.

## `minArea` (type: `integer`):

Only include properties with at least this usable area, in square metres. Leave empty for no lower limit.

## `maxArea` (type: `integer`):

Only include properties with at most this usable area, in square metres. Leave empty for no upper limit.

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

Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited. A 50,000 safety ceiling always applies — higher values are capped to 50,000. Tip: start with 10-50 to test, then increase.

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

Open each listing to collect richer data: full description, building material, condition, ownership type, floor, energy rating, and the complete photo set. Slower but much more detailed. When off, only the data shown in search results is returned.

## Actor input object example

```json
{
  "startUrls": [],
  "searchLocations": [
    "Praha"
  ],
  "dealType": "sale",
  "propertyType": "apartments",
  "maxResults": 100,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped property listings with key fields.

# 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 = {
    "startUrls": [],
    "searchLocations": [
        "Praha"
    ],
    "dealType": "sale",
    "propertyType": "apartments",
    "maxResults": 100,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/sreality-cz-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 = {
    "startUrls": [],
    "searchLocations": ["Praha"],
    "dealType": "sale",
    "propertyType": "apartments",
    "maxResults": 100,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/sreality-cz-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 '{
  "startUrls": [],
  "searchLocations": [
    "Praha"
  ],
  "dealType": "sale",
  "propertyType": "apartments",
  "maxResults": 100,
  "includeDetails": true
}' |
apify call solidcode/sreality-cz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sreality.cz Real Estate Scraper",
        "description": "[💰 $3.8 / 1K] Extract real estate listings from Sreality.cz, the largest Czech property portal. Search apartments, houses, land, and commercial properties for sale, rent, or auction by city or region. Get prices, GPS coordinates, room layouts, area, photos, agency contacts, and full descriptions.",
        "version": "1.0",
        "x-build-id": "xDnoXCZpzenxbXkDR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~sreality-cz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-sreality-cz-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/solidcode~sreality-cz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-sreality-cz-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/solidcode~sreality-cz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-sreality-cz-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Sreality.cz URLs directly — either a search-results page (with your filters already applied in the browser) or a single property page. Any filters in the URL are kept automatically. The Deal Type, Property Type, and price/area settings below do NOT apply to URLs — those come from the URL itself.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "Type Czech city or region names to search, e.g. 'Praha', 'Brno', 'Ostrava', or a whole region like 'Jihomoravský kraj'. Diacritics are optional ('Plzen' also works). Add several to scrape multiple places in one run. Leave empty if you are using URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "sale",
                            "rent",
                            "auction"
                        ],
                        "type": "string",
                        "description": "Whether to find properties for sale, for rent, or in auction. Only applies to Search Locations — ignored when using URLs (the URL sets its own deal type).",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "apartments",
                            "houses",
                            "land",
                            "commercial",
                            "other"
                        ],
                        "type": "string",
                        "description": "The kind of property to find. Only applies to Search Locations — ignored when using URLs.",
                        "default": "apartments"
                    },
                    "minPrice": {
                        "title": "Minimum Price (CZK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties priced at or above this amount, in Czech koruna (CZK). Leave empty for no lower limit."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (CZK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties priced at or below this amount, in Czech koruna (CZK). Leave empty for no upper limit."
                    },
                    "minArea": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this usable area, in square metres. Leave empty for no lower limit."
                    },
                    "maxArea": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at most this usable area, in square metres. Leave empty for no upper limit."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited. A 50,000 safety ceiling always applies — higher values are capped to 50,000. Tip: start with 10-50 to test, then increase.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Property Details",
                        "type": "boolean",
                        "description": "Open each listing to collect richer data: full description, building material, condition, ownership type, floor, energy rating, and the complete photo set. Slower but much more detailed. When off, only the data shown in search results is returned.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```