# RealtySync CZ/SK Aggregator (`conversational_kermis/realtysync-aggregator`) Actor

Aggregates property listings from Sreality, Bezrealitky.cz, Bezrealitky.sk, and iDnes Reality into a single normalized dataset. Select any combination of sources, filter by type and location, and get deduplicated results with a consistent schema.

- **URL**: https://apify.com/conversational\_kermis/realtysync-aggregator.md
- **Developed by:** [the anh nguyen](https://apify.com/conversational_kermis) (community)
- **Categories:** Real estate
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## RealtySync CZ/SK Aggregator

Query **all four Czech and Slovak real estate portals in a single run** — Sreality.cz, Bezrealitky.cz, Bezrealitky.sk, and iDnes Reality. Get a deduplicated, normalized dataset with a consistent schema across all sources.

### What does this Actor do?

This Actor runs all four RealtySync portal scrapers concurrently and merges the results:

1. **Fetches listings** from each selected portal in parallel
2. **Normalizes** all results into the same field schema (price, area, GPS, contact, images)
3. **Deduplicates** by (source, listing_id) so you never get the same listing twice
4. **Tags each listing** with its `source` field so you know where it came from

Pick any combination of portals, apply filters per portal (region, location), and get one clean dataset.

### Why use the Aggregator?

Running four separate actors and merging the output manually is tedious and error-prone. The Aggregator handles concurrency, normalization, and deduplication in one step. Use it when you need:

- **Full Czech market coverage** — Sreality + Bezrealitky + iDnes cover ~80%+ of CZ listings
- **Cross-border CZ/SK data** — add Bezrealitky.sk for Slovak listings
- **Price comparison across portals** — same property listed at different prices on different portals
- **One API call** instead of four

### How to use the Aggregator

1. **Create a free Apify account** at [apify.com](https://apify.com) if you don't have one.
2. **Open this Actor** in the Apify Console and click "Start".
3. **Select sources** — check which portals to include (all four by default).
4. **Set filters** — offer type, estate type, and per-portal location filters.
5. **Click Run** and download the merged dataset from the Output tab.

#### Input example

```json
{
    "sources": ["SREALITY", "BEZREALITKY_CZ", "IDNES"],
    "offerType": "SALE",
    "estateType": "APARTMENTS",
    "maxResultsPerSource": 50,
    "fetchDetails": true,
    "srealityRegionId": 10,
    "idnesLocationSlug": "praha"
}
````

#### Output example

```json
{
    "listing_id": "sreality-2160546636",
    "source": "sreality",
    "title": "Prodej bytu 3+kk 75 m²",
    "property_type": "APARTMENT",
    "transaction_type": "SALE",
    "price_czk": 6500000,
    "currency": "CZK",
    "locality": "Praha 5 - Smíchov",
    "area_m2": 75.0,
    "latitude": 50.0755,
    "longitude": 14.4035,
    "seller_name": "RE/MAX Praha",
    "seller_phone": "+420 123 456 789",
    "seller_is_agency": true,
    "url": "https://www.sreality.cz/detail/prodej/byty/..."
}
```

#### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sources` | array | All four | Which portals to include: SREALITY, BEZREALITKY\_CZ, BEZREALITKY\_SK, IDNES |
| `offerType` | enum | `SALE` | SALE, RENT, ALL |
| `estateType` | enum | `APARTMENTS` | APARTMENTS, HOUSES, LAND, COMMERCIAL, ALL |
| `maxResultsPerSource` | integer | `100` | Max listings per portal (total output = this x active sources) |
| `fetchDetails` | boolean | `true` | Fetch full details (GPS, specs, images) per listing |
| `srealityRegionId` | integer | *(all)* | Sreality region filter (10 = Praha, 20 = Jihomoravsky) |
| `bezrealitkyRegionOsmIds` | array | `[]` | OSM IDs for Bezrealitky (\[435514] = Praha). Find at nominatim.openstreetmap.org |
| `idnesLocationSlug` | string | *(all)* | iDnes location slug (`praha`, `brno`, etc.) |

### How much will it cost?

This Actor uses **Pay-Per-Event** pricing at **$0.004 per listing** (slightly higher than individual portal scrapers at $0.003 to cover the overhead of concurrent scraping and deduplication).

| Volume | Cost |
|--------|------|
| 100 listings (from 1 portal) | $0.40 |
| 200 listings (50 x 4 portals) | $0.80 |
| 1,000 listings | $4.00 |
| 5,000 listings | $20.00 |

You only pay for successfully scraped listings saved to the dataset. Platform costs (compute) are billed separately by Apify based on your plan.

### Tips

- Start with 2-3 portals and `maxResultsPerSource: 50` to estimate run time and cost.
- Use location filters to avoid fetching nationwide data when you only need one city.
- Combine with **Apify Scheduler** to build a daily price-tracking pipeline across all portals.
- For a single portal, use the dedicated RealtySync scraper instead — it's slightly cheaper per listing.

### Is it legal to scrape these portals?

This Actor extracts publicly available data from public web pages and APIs. Web scraping of publicly accessible information is generally permitted under applicable law. Always review the target site's Terms of Service and applicable regulations (including GDPR for EU data) before use. This Actor does not bypass authentication, paywalls, or CAPTCHAs. Use responsibly and respect rate limits.

# Actor input Schema

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

Which portals to include. Leave all selected for the full multi-portal dataset.

## `offerType` (type: `string`):

Filter by transaction type.

## `estateType` (type: `string`):

Filter by property type. Note: not all types are available on all portals.

## `maxResultsPerSource` (type: `integer`):

Maximum listings to fetch from each individual portal. 0 = no limit. Total output = this × number of active sources.

## `fetchDetails` (type: `boolean`):

Fetch individual listing pages for GPS coordinates, full specs, and images. Slower but much richer output. Disable for a fast overview scan.

## `srealityRegionId` (type: `integer`):

Sreality region ID to filter by. Example: 10 for Praha, 20 for Jihomoravský kraj. See Sreality API docs.

## `bezrealitkyRegionOsmIds` (type: `array`):

OpenStreetMap region IDs for Bezrealitky (CZ and SK). Example: \[435514] for Praha, \[14296] for Bratislava. Find IDs at nominatim.openstreetmap.org.

## `idnesLocationSlug` (type: `string`):

iDnes Reality location slug. Examples: 'praha', 'jihomoravsky-kraj', 'brno'. Leave empty for all of Czech Republic.

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

Apify proxy configuration. Recommended for production runs to avoid rate limiting.

## Actor input object example

```json
{
  "sources": [
    "SREALITY",
    "BEZREALITKY_CZ",
    "IDNES"
  ],
  "offerType": "SALE",
  "estateType": "APARTMENTS",
  "maxResultsPerSource": 50,
  "fetchDetails": true,
  "bezrealitkyRegionOsmIds": []
}
```

# 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_CZ",
        "IDNES"
    ],
    "maxResultsPerSource": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("conversational_kermis/realtysync-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_CZ",
        "IDNES",
    ],
    "maxResultsPerSource": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("conversational_kermis/realtysync-aggregator").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 '{
  "sources": [
    "SREALITY",
    "BEZREALITKY_CZ",
    "IDNES"
  ],
  "maxResultsPerSource": 50
}' |
apify call conversational_kermis/realtysync-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RealtySync CZ/SK Aggregator",
        "description": "Aggregates property listings from Sreality, Bezrealitky.cz, Bezrealitky.sk, and iDnes Reality into a single normalized dataset. Select any combination of sources, filter by type and location, and get deduplicated results with a consistent schema.",
        "version": "1.0",
        "x-build-id": "LDbCKwbA9DtUL9xin"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/conversational_kermis~realtysync-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-conversational_kermis-realtysync-aggregator",
                "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/conversational_kermis~realtysync-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-conversational_kermis-realtysync-aggregator",
                "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/conversational_kermis~realtysync-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-conversational_kermis-realtysync-aggregator",
                "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": {
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which portals to include. Leave all selected for the full multi-portal dataset.",
                        "default": [
                            "SREALITY",
                            "BEZREALITKY_CZ",
                            "BEZREALITKY_SK",
                            "IDNES"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "offerType": {
                        "title": "Offer Type",
                        "enum": [
                            "SALE",
                            "RENT",
                            "ALL"
                        ],
                        "type": "string",
                        "description": "Filter by transaction type.",
                        "default": "SALE"
                    },
                    "estateType": {
                        "title": "Estate Type",
                        "enum": [
                            "APARTMENTS",
                            "HOUSES",
                            "LAND",
                            "COMMERCIAL",
                            "ALL"
                        ],
                        "type": "string",
                        "description": "Filter by property type. Note: not all types are available on all portals.",
                        "default": "APARTMENTS"
                    },
                    "maxResultsPerSource": {
                        "title": "Max Results Per Source",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listings to fetch from each individual portal. 0 = no limit. Total output = this × number of active sources.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Fetch Full Details",
                        "type": "boolean",
                        "description": "Fetch individual listing pages for GPS coordinates, full specs, and images. Slower but much richer output. Disable for a fast overview scan.",
                        "default": true
                    },
                    "srealityRegionId": {
                        "title": "Sreality Region ID",
                        "type": "integer",
                        "description": "Sreality region ID to filter by. Example: 10 for Praha, 20 for Jihomoravský kraj. See Sreality API docs."
                    },
                    "bezrealitkyRegionOsmIds": {
                        "title": "Bezrealitky Region OSM IDs",
                        "type": "array",
                        "description": "OpenStreetMap region IDs for Bezrealitky (CZ and SK). Example: [435514] for Praha, [14296] for Bratislava. Find IDs at nominatim.openstreetmap.org.",
                        "default": []
                    },
                    "idnesLocationSlug": {
                        "title": "iDnes Location Slug",
                        "type": "string",
                        "description": "iDnes Reality location slug. Examples: 'praha', 'jihomoravsky-kraj', 'brno'. Leave empty for all of Czech Republic."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Recommended for production runs to avoid rate limiting."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```