# Czech Real Estate Aggregator: Sreality, Bezrealitky & iDNES (`tsutseisoftware/czech-real-estate-aggregator`) Actor

All big Czech property portals in one run: Sreality.cz, Bezrealitky.cz and iDNES Reality. One row per property with duplicates merged, price per m² vs. the district median, monitoring of new and changed listings, market summary, notifications. Unofficial.

- **URL**: https://apify.com/tsutseisoftware/czech-real-estate-aggregator.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 property (aggregation)s

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/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 Real Estate Aggregator: Sreality, Bezrealitky & iDNES

Get the property listings of **all big Czech real estate portals in one run**: **Sreality.cz**, **Bezrealitky.cz** and **iDNES Reality**, with **one row per property**: the same flat listed on several portals is **merged into one row** with all its portals and links, and you pay for it once. For investors, agencies and analysts who want the whole market without three tools: type your search once (sale or rent, flats, houses, land or commercial, towns, regions or districts, price, area, layout, floor, features) and every row has the same fields whatever the portal: price, price per m², area, layout, address with district and region, GPS, seller, photos, and with details the description and all parameters.

**Price:** the price of the portal's own actor plus $0.30 per 1 000 properties for the aggregation, e.g. **$1.09 per 1 000 properties from Sreality.cz** (FREE plan, proxy included).

> **Česky:** Inzeráty ze **všech velkých českých realitních portálů v jednom běhu**: Sreality.cz, Bezrealitky.cz a iDNES Reality. Hledání zadáte jednou (prodej nebo pronájem, byty, domy, pozemky, obec, kraj, okres, cena, plocha, dispozice) a dostanete **jeden řádek za nemovitost**: stejný byt z více portálů se sloučí s odkazy na všechny. Jednotná pole, **cena za m² proti mediánu okresu**, monitoring nových a zlevněných nabídek, upozornění do Telegramu, Slacku, Discordu nebo WhatsAppu a přehled trhu. Výstup do Excelu, CSV nebo JSON. Podporu poskytujeme i česky.

### Why use this Czech real estate aggregator?

- 🏠 **Every big Czech property portal at once:** Sreality.cz, Bezrealitky.cz and iDNES Reality with one input, with the same filters and the same data quality as our single-portal actors.
- 🔗 **Duplicates merged, paid once:** in big towns 15 to 30 % of the listings are the same property on another portal. Each property is **one row** with `portals` and `sources` (every listing with its link and price), and you pay for it once, at the price of its cheapest portal.
- 📉 **Bargains stand out:** every row says how its **price per m² compares with the median of its district** (`pricePerSqmVsMarketAreaPercent: -12.5`); optionally the **rental yield** of flats for sale, and a free **market summary** with every run (price per m² quartiles by district, layouts, private sellers, listings per portal).
- 📋 **One schema for all portals:** price, price per m², usable and plot area, layout, street, town part, town, district, region, GPS, floor, condition, construction, ownership, energy class, balcony, cellar, parking, seller and agency, photos, dates. **Compact output** for AI agents, MCP clients and spreadsheets.
- 📬 **Monitoring across portals:** schedule it daily and get (and pay the full price for) only the properties that are new, cheaper or otherwise changed on any portal, with a **notification to Telegram, Slack, Discord, WhatsApp or your webhook** ($0.001 per run that sent one).
- 🔒 **Privacy first:** no phone numbers or e-mails: they are removed from descriptions, and agency names that are a person's name are hidden, as in each portal's actor.

### Portals

| Portal | `sources` value | Price per 1 000 listings | With listing details | Notes |
|---|---|---|---|---|
| Sreality.cz | `sreality` | $0.79 | +$0.65 | the biggest Czech portal; proxy included |
| Bezrealitky.cz | `bezrealitky` | $1.30 | +$0.15 | private owners, no agencies; no auctions |
| iDNES Reality | `idnes` | $3.80 | +$1.75 | agencies and developers |

By default the actor reads all three portals, one after another, each up to **Max listings per portal** (by default its share of **Max listings**: Max listings ÷ number of portals + 20 %). With many duplicates between the portals (15 to 30 % in big towns) the run then saves fewer properties than Max listings: set **Max listings per portal** higher to fill it.

### How to scrape all Czech real estate portals

1. Choose the **Portals**, the **Transaction** (sale, rent, auction) and the **Property types**.
2. Add **Locations** (e.g. `Brno`, `Praha 6`), **Regions** or **Districts**, and optionally layouts (`2+kk`), price, area, floor, features or seller.
3. Set **Max listings** (saved properties after merging) and **Max listings per portal**.
4. Run it and download the dataset as Excel, CSV or JSON, or schedule it daily with **Monitoring: only new or changed listings** and a notification.

### Use cases

Copy an input into the **JSON** tab of the input and adjust it.

**Daily watchdog: new and cheaper flats for rent in Brno from all portals, to Telegram:**

```json
{
  "transactionType": "rent",
  "propertyTypes": ["flat"],
  "locations": ["Brno"],
  "maxItems": 0,
  "onlyNewOrChanged": true,
  "monitoringKey": "brno-rent",
  "telegramBotToken": "123456:ABC…",
  "telegramChatId": "123456789"
}
```

**Investor shortlist: flats for sale in Prague 10 with the price against the district and the rental yield:**

```json
{
  "transactionType": "sale",
  "propertyTypes": ["flat"],
  "locations": ["Praha 10"],
  "includeRentalYield": true,
  "rentalSampleSize": 300,
  "maxItems": 500
}
```

**The whole market of one region, one row per property, with details:**

```json
{
  "transactionType": "sale",
  "propertyTypes": ["flat", "house"],
  "regions": ["jihomoravsky-kraj"],
  "includeDetails": true,
  "maxItems": 0
}
```

**2+kk and 3+kk for sale in Brno up to 8 million, the cheapest read first on each portal:**

```json
{
  "transactionType": "sale",
  "propertyTypes": ["flat"],
  "subtypes": ["2+kk", "3+kk"],
  "locations": ["Brno"],
  "maxPrice": 8000000,
  "sortBy": "priceAsc",
  "maxItems": 300
}
```

#### Merging duplicates

The same property listed on several portals becomes **one row** with all its links and prices: `portals` lists all portals of the property, `sources` every listing with its URL and price, `duplicates` how many listings were merged. The most complete listing is kept and filled from the others. Merging is strict, so two different properties are never joined: listings without a price or an area are never merged, and two listings of one portal are never merged (e.g. two identical flats of a development). Turn off **Merge duplicates across portals** for one row per listing.

A property whose price or area differs between portals (an old price on one of them, the area with or without the balcony) is not merged.

#### Price per m² vs. the district

`pricePerSqm` is the portal's own value, or the price divided by the usable area for sales of flats and houses (rentals: the monthly rent per m² when the portal gives it). `marketArea` is the district (okres; in Prague the city district when the portal gives it, else the town), `marketAreaListings` the number of listings of the run with the same transaction and property type there, `marketAreaMedianPricePerSqm` their median (`null` when there are too few) and `pricePerSqmVsMarketAreaPercent` how far above (+) or below (−) the median the listing is. The comparison uses the listings of your run, so a search of a whole district or region gives the best medians. In Prague, Bezrealitky.cz gives no city district, so its listings are compared with the whole of Prague and those of Sreality.cz and iDNES Reality with their city district (Praha 1 to Praha 10).

#### Rental yield (optional)

Turn on **Add rental yield (flats for sale)** and each flat for sale gets an **estimated monthly rent** and its **gross rental yield**, from flats for rent that the same run reads in the same places, as local as the data allows. `rentBasis` says what the estimate is based on and `rentSampleSize` how many rentals it is; `rentEstimateMonthly` is the estimated monthly rent and `grossRentalYieldPercent` = 12 × estimated rent / price × 100. **Rental yield: rentals to read** (300 by default) is shared by the portals; up to a fifth more rentals may be read and paid for, and the same flat on several portals counts once. Big flats (4 and more rooms) often have too few rentals of their size, so their estimate is less local and often too high (check `rentBasis`).

**What the yield is not.** It is an estimate from **asking** prices on the portals, not from signed leases or a valuation. It is a **gross** yield: no income tax, vacancy, repairs fund (fond oprav), service charges paid by the owner, insurance, purchase costs or mortgage. Rents and flats differ in condition, floor, furnishing and street, and the median does not see that. Where the run finds too few comparable rentals the fields are `null` (more rentals to read = more districts with a yield). Bezrealitky.cz gives Prague listings without the city district, so they are compared with the whole of Prague (`rentBasis: town…`). Use it to compare districts and to shortlist flats, not as investment advice.

The `SUMMARY` record gets `rentalYield`: rentals read and used, median gross yield, and by district the number of flats, their median yield, the rentals and the median rent per m².

Price: **$0.50 per 1 000 flats with a yield** (`rental-yield`, only flats that got one), plus the rentals read at **$0.02 per 1 000** (charged as `monitoring-check` units). 300 rentals add $0.006 to a run.

#### Monitoring mode

With **Monitoring: only new or changed listings** the actor remembers the merged properties of the previous run with the same **Monitoring key** and saves only properties that are new (`changeType: new`) or whose price, name, portals, discount or reservation changed (`updated`, with `changedFields`). Each portal is read completely up to its limit, so a property is new only if no portal had it before. A property keeps its row ID whichever of its portals are read, and when a portal could not be read in a run, its missing listings are not reported as a change.

#### Notifications

Fill in one or more channels in the **Notifications** section (Telegram bot token and chat ID, Slack or Discord webhook, WhatsApp access token with your business phone number ID and the recipient's number, or any HTTPS webhook). After the run, the actor sends the name, place, price and link of the saved properties (at most **Notifications: max listings per message**) and links to the run and the dataset; with **only when something was saved** (on by default) a run without new listings sends nothing. Tokens and URLs are secret inputs, never logged. A run that sent its notification pays **$0.001** once (all channels together); a run that sends nothing pays nothing.

#### Market summary (SUMMARY)

Every run saves a free JSON record `SUMMARY` in the key-value store: listings found, properties saved, merged duplicates and properties on several portals; price per m² quartiles by transaction and property type and by district; flat layouts; share of private sellers; and for every portal the listings read, its status message and how many saved properties were found there.

### How much does it cost?

Pay per result. A property found on several portals pays its **cheapest** portal **once**, so merging never makes a property dearer. Merged duplicates, filtered-out listings and the `SUMMARY` record are free. Platform usage and proxies are included.

| Charge | Price (FREE plan) | When |
|---|---|---|
| Property from its portal | Sreality.cz $0.79, Bezrealitky.cz $1.30, iDNES Reality $3.80 per 1 000 (the same as the portal's own actor) | every saved property |
| Listing details | +$0.65 / +$0.15 / +$1.75 per 1 000 | with **Add listing details**: the cheapest portal whose page was read, once |
| Aggregation (merging, one schema, price vs. district, monitoring across portals) | $0.30 per 1 000 properties ($0.28 Bronze, $0.25 Silver, $0.20 Gold and higher) | every saved property |
| Rental yield | $0.50 per 1 000 flats with a yield, plus $0.02 per 1 000 rentals read | with **Add rental yield** |
| Start | $0.005 per run | every run |
| Notification | $0.001 per run | a run that sent one |
| Monitoring check | $0.02 per 1 000, with details +$0.10 (Sreality.cz +$0.20) | an unchanged property in monitoring mode: not saved, but read again; always much less than saving it |
| Extra pages | $0.10 per 1 000 pages (Sreality.cz $1.20) | pages a narrow filter read and threw away, searches without results; a normal run pays nothing here |

If the saved properties don't cover a run's cost (e.g. a slow or rejecting portal keeps the run waiting), the difference is charged as small check units (`monitoring-check`); the log says how many. A normal run pays nothing more. You can set a maximum cost per run: the portals then read only as many listings as it pays for, and saving stops when it is reached.

| Example (FREE plan) | Price |
|---|---|
| 1 000 properties from Sreality.cz | $0.79 + $0.30 = **$1.09** |
| 1 000 properties from Bezrealitky.cz | $1.30 + $0.30 = **$1.60** |
| 1 000 properties from iDNES Reality with details | $3.80 + $1.75 + $0.30 = **$5.85** |
| 100 properties from all three portals | between $0.11 and $0.41 |
| 100 flats for sale with rental yield from 300 rentals (Sreality.cz) | $0.079 + $0.030 + $0.050 + $0.006 = **$0.165** |

### Input example

```json
{
  "sources": ["sreality", "bezrealitky", "idnes"],
  "transactionType": "sale",
  "propertyTypes": ["flat"],
  "subtypes": ["2+kk", "3+kk"],
  "locations": ["Brno"],
  "maxPrice": 8000000,
  "maxItems": 200,
  "maxItemsPerSource": 100
}
```

### Output example

```json
{
  "id": "cz-reality:sreality:4051095628",
  "portal": "sreality",
  "portals": ["sreality", "bezrealitky", "idnes"],
  "sources": [
    {"portal": "sreality", "url": "https://www.sreality.cz/detail/prodej/byt/2+kk/praha-vrsovice-ruska/4051095628", "id": "sreality:4051095628", "price": 7999900, "detailScraped": false},
    {"portal": "bezrealitky", "url": "https://www.bezrealitky.cz/nemovitosti-byty-domy/1053357-nabidka-prodej-bytu-ruska-praha", "id": "bezrealitky:1053357", "price": 7999900, "detailScraped": false},
    {"portal": "idnes", "url": "https://reality.idnes.cz/detail/prodej/byt/praha-10-ruska/6a75abf49092cfef280d061a/", "id": "idnes:6a75abf49092cfef280d061a", "price": 7999900, "detailScraped": false}
  ],
  "duplicates": 2,
  "url": "https://www.sreality.cz/detail/prodej/byt/2+kk/praha-vrsovice-ruska/4051095628",
  "name": "Prodej bytu 2+kk 42 m²",
  "transactionType": "sale",
  "propertyType": "flat",
  "subtype": "2+kk",
  "price": 7999900,
  "priceCurrency": "CZK",
  "pricePerSqm": 190474,
  "usableArea": 42,
  "region": "Hlavní město Praha",
  "district": "Praha 10",
  "city": "Praha",
  "cityPart": "Vršovice",
  "street": "Ruská",
  "marketArea": "Praha 10",
  "marketAreaListings": 19,
  "marketAreaMedianPricePerSqm": 190474,
  "pricePerSqmVsMarketAreaPercent": 0.0,
  "country": "CZ",
  "scrapedAt": "2026-11-09T12:26:02Z"
}
```

See the **Output** tab for all fields. The dataset has views **Overview**, **Price per m² vs. district**, **Rental yield**, **Portals and duplicates** and **Monitoring**.

### Limitations

- Near the run's timeout the actor stops reading (keeping time to save and charge what it has read); a run restarted by the platform (migration) continues where it stopped, only a quick portal may be read again.

- The rental yield is a gross estimate from asking prices of the run's rentals (see [Rental yield](#rental-yield-optional)): no taxes, vacancy, repairs fund or service charges, and `null` where there are too few comparable rentals.

- Each portal searches locations its own way, so the same search gives a different number of listings on each portal.

- Not every filter exists on every portal: iDNES Reality has no floor and no energy class filter, Bezrealitky.cz no listing age filter and no auctions. Such a filter is left out for that portal and the run log says so.

- Kinds of houses, land and commercial property are named differently on each portal; a layout or kind a portal doesn't know stops that portal (named in the status message), the others are saved. Flat layouts (`2+kk`, `3+1`…) work on all three.

- Portals are read one after another; a portal that cannot be read (blocked, website change) is skipped and named in the status message, the others are saved.

- Filters a portal cannot apply in its search (on iDNES Reality the seller, the floor and some features) are checked by the actor on the listings it reads. A narrow combination then reads many search pages for a few listings; these extra pages are charged (see the pricing) and the run takes longer. Use fewer such filters or a smaller area.

- **Sort by** orders the listings on each portal (which ones are read first); the rows of the run are not sorted across portals.

- In small towns, iDNES Reality listings are often merged with the other portals only with **Add listing details**.

- Removed listings (monitoring) are not reported yet.

- The price per m² comparison uses the listings of your run, not official statistics.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/czech-real-estate-aggregator").call(run_input={
    "transactionType": "rent", "propertyTypes": ["flat"], "locations": ["Brno"], "maxItems": 200,
})
for prop in client.dataset(run.default_dataset_id).iterate_items():
    print(prop["name"], prop["price"], prop["pricePerSqmVsMarketAreaPercent"], prop["portals"])
```

### Troubleshooting

| Status message | What to do |
|---|---|
| `No portal could be read (…)` | The reason of each portal follows in brackets (e.g. a layout or kind it doesn't know). Fix the input, or try again later. |
| `…; could not be read: <portal>` | That portal was skipped (e.g. the website rejected the run or changed); the others are saved. Try again later. |
| `…; skipped: <portal> (…)` | The portal has nothing for this search (e.g. auctions on Bezrealitky.cz); the reason is in brackets. |
| `(stopped at Max listings, N)` | Raise **Max listings**, or **Max listings per portal** when many duplicates were merged. |
| `(stopped at your maximum cost per run)` | Raise the maximum cost per run in the run options. |
| `rental yield for 0 flats` | Read more rentals (**Rental yield: rentals to read**) or search a bigger area. |

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More Czech real-estate scrapers

The same output format for the other big Czech real-estate portals (many listings are published on several of them):

- [Sreality.cz Scraper](https://apify.com/tsutseisoftware/sreality-scraper): the biggest Czech real-estate portal: price per m², GPS, agency, monitoring
- [iDNES Reality Scraper](https://apify.com/tsutseisoftware/idnes-reality-scraper): reality.idnes.cz: flats, houses, land, rentals and auctions, price per m², GPS, monitoring
- [Bezrealitky.cz Scraper](https://apify.com/tsutseisoftware/bezrealitky-scraper): flats, houses and rentals from private owners: price per m², charges, GPS, walking distances, monitoring

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape Czech real estate portals?

The actor reads only publicly available listings, without logging in, at a moderate speed, slows down when a portal asks, never changes IP address to get around a limit and never solves captchas or other challenges. It returns no phone numbers or e-mails, removes them from descriptions and hides agency names that are a person's name. You are responsible for how you use the data (GDPR, database rights and the websites' terms). This actor is not affiliated with any of the portals.

#### Why is a property not merged with its copy on another portal?

The portals sometimes show a different price (an old price, the price with or without the commission) or a different area (with or without the balcony or cellar) for the same property, or another town name. Merging is strict, so that two different properties are never joined. In small towns iDNES Reality listings often have too little location data: turn on **Add listing details** to have them merged.

#### How accurate is the rental yield?

It is as good as the asking rents of the run: a median of comparable flats for rent, as local as the data allows. Asking rents are usually a little above signed leases, and the yield is gross (no taxes, vacancy, repairs fund or service charges), so the net yield of a real purchase is lower. Every row says what the estimate is based on (`rentBasis`, `rentSampleSize`, `rentPerSqmMedian`), so you can ignore estimates from few rentals. In a local test on 9 November 2026 (flats for sale in Prague 10, 180 rentals read) the median rent was 444 CZK per m² and the gross yields 2.3–4.0 %, median 3.1 %.

#### Can I get one portal only?

Yes, choose one portal; you pay its price plus the aggregation. For one portal its own actor is cheaper: [Sreality.cz Scraper](https://apify.com/tsutseisoftware/sreality-scraper), [Bezrealitky.cz Scraper](https://apify.com/tsutseisoftware/bezrealitky-scraper) or [iDNES Reality Scraper](https://apify.com/tsutseisoftware/idnes-reality-scraper).

***

Also known as a Czech real estate API, "všechny realitní inzeráty na jednom místě", "realitní agregátor" or "hlídač realit Sreality, Bezrealitky a iDNES".

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/czech-real-estate-aggregator/changelog.md

# Actor input Schema

## `sources` (type: `array`):

Portals to read, one after another. A property found on several portals is one row and pays the price of its cheapest portal once. Proxies are set by default and included in the price.

## `transactionType` (type: `string`):

Sale, rent or auction. Bezrealitky.cz has no auctions (it is skipped for them).

## `propertyTypes` (type: `array`):

Empty = flats. On Bezrealitky.cz houses include cottages, commercial means offices and commercial spaces, and other means garages.

## `subtypes` (type: `array`):

Flat layouts as the portals name them: 1+kk, 1+1, 2+kk, 2+1, 3+kk, 3+1, 4+kk, 4+1, 5+kk, 5+1, "6 a více". Kinds of houses and land are named differently on each portal; a portal that does not know a value reports it and is skipped.

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

Towns, city parts or streets in words (e.g. "Brno", "Praha 6", "Smíchov"), looked up like each portal's search box. At most 10.

## `radiusKm` (type: `integer`):

Also listings up to this distance around each location (iDNES Reality rounds up to 0.5, 1, 5, 10 or 20 km). 0 = only the location itself.

## `regions` (type: `array`):

Whole regions. Empty (with no locations or districts) = the whole country.

## `districts` (type: `array`):

Districts by name, e.g. "Brno-město", "Praha-západ", "Kladno".

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

Maximum number of properties saved (after merging duplicates). 0 = no limit.

## `maxItemsPerSource` (type: `integer`):

How many listings each portal reads at most. 0 = its share of "Max listings" (Max listings ÷ number of portals + 20 %).

## `sortBy` (type: `string`):

Order of the results on each portal (which listings are read first when a limit stops the run).

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

For rentals the monthly rent.

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

For rentals the monthly rent.

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

Usable area.

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

Usable area.

## `minPlotArea` (type: `integer`):

Houses and land.

## `maxPlotArea` (type: `integer`):

Houses and land.

## `minPricePerSqm` (type: `integer`):

Only listings with at least this price per m² (rentals: monthly rent per m²).

## `maxPricePerSqm` (type: `integer`):

Only listings with at most this price per m² (finds bargains).

## `minFloor` (type: `integer`):

Flats on this floor or higher (0 = ground floor). Not available on iDNES Reality (read without it).

## `maxFloor` (type: `integer`):

Flats on this floor or lower. Not available on iDNES Reality (read without it).

## `maxAgeDays` (type: `integer`):

Only listings published in this many days. Bezrealitky.cz has no such filter (read without it). Empty = any age.

## `features` (type: `array`):

Only listings with these features (each portal's own filter).

## `furnished` (type: `array`):

Furnishing (mostly for rentals).

## `energyClasses` (type: `array`):

Only these energy classes. Not available on iDNES Reality (read without it).

## `sellerType` (type: `string`):

On Bezrealitky.cz (private owners) "Agencies only" means its partners and developer projects.

## `onlyDiscounted` (type: `boolean`):

Only listings marked as discounted (Zlevněno).

## `onlyWithPrice` (type: `boolean`):

Skip listings with the price on request.

## `onlyWithGps` (type: `boolean`):

Skip listings without coordinates (on iDNES Reality GPS comes with "Add listing details").

## `onlyWithImages` (type: `boolean`):

Skip listings without photos.

## `descriptionContains` (type: `string`):

Full-text search in titles and descriptions (e.g. "sauna", "výhled").

## `excludeKeywords` (type: `array`):

Skip listings whose title (or description, with details) contains any of these words, e.g. "podíl".

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

Read each listing's page too: description, all parameters (floor, condition, ownership, energy class, balcony…), GPS on iDNES Reality. Slower and paid per listing with its page read (the price of the portal's own actor, see the README).

## `mergeDuplicates` (type: `boolean`):

One row per property when the same property is on several portals, with all its portals and links in "portals" and "sources". Merging is strict, so two different properties are never joined. Off = one row per listing.

## `includeRentalYield` (type: `boolean`):

Also reads flats for rent in the same places and adds to each flat for sale an estimated monthly rent from comparable rentals of the same run and the gross rental yield. An estimate from asking prices, without taxes, vacancy or service charges; null where the run finds too few comparable rentals. $0.50 per 1 000 flats with a yield, plus $0.02 per 1 000 rentals read.

## `rentalSampleSize` (type: `integer`):

How many flats for rent are read for the medians (shared by the portals). More rentals = more districts and layouts with a yield.

## `compactOutput` (type: `boolean`):

Only the core fields (id, portals, URL, name, type, layout, price, price per m², area, place, GPS, seller, price vs. district), plus the description and the monitoring fields when those are on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `onlyNewOrChanged` (type: `boolean`):

Return only properties that are new or whose price, name, portals, discount or reservation changed since the previous run with the same Monitoring key. Unchanged properties are not saved and pay only a small check fee ($0.02 per 1 000, see the README).

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for each search you monitor.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID".

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL: gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many properties are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no property (e.g. a monitoring run without new listings).

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "sources": [
    "sreality",
    "bezrealitky",
    "idnes"
  ],
  "transactionType": "sale",
  "propertyTypes": [
    "flat"
  ],
  "regions": [
    "praha"
  ],
  "maxItems": 30,
  "maxItemsPerSource": 10,
  "sortBy": "newest",
  "sellerType": "any",
  "onlyDiscounted": false,
  "onlyWithPrice": false,
  "onlyWithGps": false,
  "onlyWithImages": false,
  "includeDetails": false,
  "mergeDuplicates": true,
  "includeRentalYield": false,
  "rentalSampleSize": 300,
  "compactOutput": false,
  "onlyNewOrChanged": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "sendErrorReports": true
}
```

# Actor output Schema

## `listings` (type: `string`):

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sources": [
        "sreality",
        "bezrealitky",
        "idnes"
    ],
    "transactionType": "sale",
    "propertyTypes": [
        "flat"
    ],
    "regions": [
        "praha"
    ],
    "maxItems": 30,
    "maxItemsPerSource": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/czech-real-estate-aggregator").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 = {
    "sources": [
        "sreality",
        "bezrealitky",
        "idnes",
    ],
    "transactionType": "sale",
    "propertyTypes": ["flat"],
    "regions": ["praha"],
    "maxItems": 30,
    "maxItemsPerSource": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/czech-real-estate-aggregator").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 '{
  "sources": [
    "sreality",
    "bezrealitky",
    "idnes"
  ],
  "transactionType": "sale",
  "propertyTypes": [
    "flat"
  ],
  "regions": [
    "praha"
  ],
  "maxItems": 30,
  "maxItemsPerSource": 10
}' |
apify call tsutseisoftware/czech-real-estate-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/czech-real-estate-aggregator"
        }
    }
}
```

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/EQK3CFkpnmhoeTD8r/builds/dBAccY4zn1OMRqUf6/openapi.json
