# Sreality Czech Property Listings Scraper (`automation-lab/sreality-cz-property-listings-scraper`) Actor

Export public Sreality.cz sale and rental searches with stable listing IDs, CZK prices, layouts, locations, images, URLs, and available agency metadata.

- **URL**: https://apify.com/automation-lab/sreality-cz-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.28 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Czech Property Listings Scraper

Export **Sreality Czech property listings** from public sale and rental search pages into clean, structured dataset rows.

Use the same transaction, property type, location, and other filters available on Sreality.cz. The Actor preserves stable listing IDs so recurring runs can power inventory snapshots, price comparisons, and change detection.

### What does this Sreality scraper do?

The Actor reads one or more public Sreality.cz search-result URLs and exports the listings visible through those searches.

Each result can include:

- stable Sreality listing ID;
- title, transaction, property type, and layout;
- CZK price and CZK price per square metre when available;
- locality, city, district, region, street, and coordinates;
- listing URL and all images exposed in the search result;
- agency identity and logo when available;
- video and Matterport availability;
- search URL and extraction timestamp for provenance.

It paginates search results, applies a global output limit, and deduplicates overlapping searches by listing ID.

### Who is it for?

This Actor is useful for:

- real-estate analysts comparing Czech asking prices;
- agencies monitoring competing inventory;
- investors screening sale listings by area and location;
- rental operators tracking available apartments;
- data teams maintaining recurring market snapshots;
- researchers exporting Czech property data to spreadsheets or BI tools.

The Actor exports current public listing snapshots. It does not create historical price changes by itself; schedule runs and compare records by `listingId` in your own dataset or workflow.

### Why use this Actor?

Sreality search pages are designed for browsing, not repeatable data export.

This Actor provides:

- deterministic IDs for joining results over time;
- typed JSON, CSV, Excel, XML, RSS, and API dataset exports through Apify;
- support for any public filters encoded in a Sreality search URL;
- sale and rental searches in one run;
- bounded pagination and retries;
- lightweight HTTP extraction at 256 MB with a datacenter proxy, without downloading images or opening detail pages.

Unlike deep-detail products, this Actor focuses on efficient search-result monitoring. It does not claim seller phone numbers, full descriptions, or hidden detail-page fields.

### Getting started

1. Open Sreality.cz and configure the transaction, property type, location, and other filters you need.
2. Copy the resulting search URL.
3. Add it to **Sreality search URLs** in the Actor input.
4. Set **Maximum listings** to the number of unique records required.
5. Click **Start**.
6. Open the default dataset and export the `overview` view.
7. For monitoring, schedule the Task and compare records by `listingId`.

The prefilled Prague apartment-sale search works without a login; the default Apify datacenter proxy provides stable cloud delivery.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | Prague apartments for sale | Public `sreality.cz` search-result URLs. Strings and request-list objects are supported. |
| `maxItems` | integer | `50` | Maximum unique listings across all searches; range 1–10,000. |
| `maxRequestRetries` | integer | `3` | Attempts for temporary HTTP 429 or 5xx responses; range 1–5. |
| `proxyConfiguration` | object | Apify datacenter proxy | Proxy configuration for stable cloud delivery. No residential fallback is automatic. |

Only Sreality.cz URLs whose path contains `/search/` are accepted. Unsupported domains fail before any source request.

#### Example input: Prague apartments for sale

```json
{
  "startUrls": [
    { "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha" }
  ],
  "maxItems": 20
}
```

#### Example input: compare sales and rentals

```json
{
  "startUrls": [
    { "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha" },
    { "url": "https://www.sreality.cz/en/search/to-rent/apartments/praha" }
  ],
  "maxItems": 40
}
```

### Output fields

| Field | Meaning |
| --- | --- |
| `listingId` | Stable numeric Sreality listing identifier. |
| `title` | Public listing headline, often including layout and area. |
| `transaction` | Sale or lease transaction label. |
| `propertyType` | Apartments, houses, land, or another source category. |
| `layout` | Source layout such as `2+kk` or `3+kt`. |
| `priceCzk` | Advertised CZK price when numeric. |
| `pricePerSqmCzk` | Advertised CZK/m² when provided. |
| `priceSummaryCzk` | Source summary price when provided. |
| `priceUnit` | Source price unit, such as per property or per month. |
| `locality` | Human-readable locality assembled from source fields. |
| `city`, `cityPart`, `district`, `region`, `street`, `country` | Available structured location components. |
| `latitude`, `longitude` | Public listing coordinates when available. |
| `areaSqm` | Area parsed from the listing title when present. |
| `url` | Canonical public listing detail URL. |
| `imageUrls` | Public image URLs exposed in the search result; images are not downloaded. |
| `agencyId`, `agencyName`, `agencyLogoUrl` | Available agency metadata. |
| `hasVideo`, `hasMatterport` | Source flags for rich media availability. |
| `sourceUrl` | Exact paginated search URL that produced the record. |
| `scrapedAt` | UTC ISO timestamp for the snapshot. |

Optional fields are omitted when Sreality does not expose them for a listing.

### Example output

A current Prague sale run produces records shaped like this:

```json
{
  "listingId": 342675532,
  "title": "For sale apartment 3+kt 66 m²",
  "transaction": "Sale",
  "propertyType": "Apartments",
  "layout": "3+kt",
  "priceCzk": 12900000,
  "pricePerSqmCzk": 195455,
  "priceUnit": "per property",
  "locality": "U Sluncové, Karlín, Praha, Praha 8, Prague",
  "city": "Praha",
  "district": "Praha 8",
  "areaSqm": 66,
  "url": "https://www.sreality.cz/en/detail/sale/flat/3+kt/praha-karlin-u-sluncove/342675532",
  "imageUrls": ["https://d18-a.sdn.cz/example.jpeg"],
  "hasVideo": false,
  "hasMatterport": false,
  "sourceUrl": "https://www.sreality.cz/en/search/for-sale/apartments/praha",
  "scrapedAt": "2026-09-08T20:31:57.395Z"
}
```

Values and availability change with the live source. The shortened image URL above illustrates the field shape.

### How much does it cost to scrape Sreality property listings?

Pay-per-event billing has two parts:

- **$0.005** when a run starts;
- one `item` event for each unique property listing saved.

Per-listing prices depend on your Apify tier:

| Tier | Price per listing |
| --- | ---: |
| FREE | $0.00437 |
| BRONZE | $0.00380 |
| SILVER | $0.002964 |
| GOLD | $0.00228 |
| PLATINUM | $0.00228 |
| DIAMOND | $0.00228 |

At BRONZE rates, 20 listings cost about **$0.081** including the start event; 100 listings cost about **$0.385**. Apify platform usage is included under PPE pricing. Failed, duplicate, or rejected records are not charged as items.

### Scheduled market monitoring

Create an Apify Task with the filters you want to follow, then schedule it daily or weekly.

A downstream workflow can:

1. use `listingId` as the stable key;
2. compare the newest `priceCzk` with the previous snapshot;
3. flag IDs not seen before as new inventory;
4. flag missing IDs as potentially removed inventory;
5. send changes to Google Sheets, a webhook, database, or dashboard.

Source listings can be edited or removed between runs. Keep timestamps and source URLs with every snapshot.

### Export and integrations

The default Apify dataset supports JSON, CSV, Excel, XML, RSS, and API retrieval.

Common integrations include:

- Google Sheets for small recurring inventories;
- Make or Zapier for alerts and routing;
- webhooks for run-completion notifications;
- BigQuery, Snowflake, or PostgreSQL for long-term snapshots;
- Python or JavaScript for custom deduplication and analysis.

The `overview` dataset view puts IDs, prices, locations, URLs, images, agencies, and timestamps first.

### Run through the Apify API

Replace `<APIFY_TOKEN>` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sreality-cz-property-listings-scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.sreality.cz/en/search/for-sale/apartments/praha"}],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sreality-cz-property-listings-scraper').call({
  startUrls: [{ url: 'https://www.sreality.cz/en/search/to-rent/apartments/praha' }],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/sreality-cz-property-listings-scraper").call(run_input={
    "startUrls": [{"url": "https://www.sreality.cz/en/search/for-sale/apartments/praha"}],
    "maxItems": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/sreality-cz-property-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Desktop and editor clients such as **Claude Desktop**, **Cursor**, and **VS Code** can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/sreality-cz-property-listings-scraper"
    }
  }
}
```

Example prompts:

- “Export 20 Prague rental apartments from this Sreality search URL.”
- “Run my saved Sreality sale and rental searches and summarize median asking price per square metre.”
- “Compare these results with yesterday’s dataset by listingId.”

The AI assistant can run the Actor; comparison quality still depends on the datasets and analysis instructions you provide.

### Reliability and retries

The Actor reads structured state embedded in Sreality's server-rendered HTML.

It retries only temporary rate limits and server errors with bounded exponential backoff. Invalid inputs, permanent 4xx responses, and source-format changes fail clearly instead of silently returning an empty successful dataset.

HTTP through Apify's datacenter proxy is the stable cloud default. You may disable it for direct local requests. The Actor never turns on an unmeasured residential proxy automatically.

### Limits

- Only public Sreality search-result URLs are supported.
- Output reflects the source at run time and is not guaranteed complete if Sreality changes or removes listings.
- Search pages do not expose every detail-page field.
- Seller contact details, full descriptions, nearby points of interest, and historical changes are not extracted.
- Area is parsed from the title and can be absent when the title does not include m².
- Location precision follows the public source and may be approximate.
- Very large runs take longer and are more exposed to source changes or rate limits.

### Troubleshooting

**The Actor rejects my URL.**

Use a public `https://www.sreality.cz/.../search/...` result page, not a listing detail URL, another domain, or a redirect service.

**The run returns fewer rows than `maxItems`.**

The search may contain fewer available results, overlapping search URLs may produce duplicates, or the last page may be exhausted.

**The run fails with a source-format error.**

Sreality may have changed its embedded page data. Retry once later; repeated failures should be reported with the run ID and input URL.

**Should I enable a proxy?**

The default datacenter proxy is recommended for cloud runs because direct cloud delivery can intermittently return HTTP 404. Residential proxy traffic is not required or enabled automatically.

### Legality and responsible use

Scrape only public data that you are entitled to process.

Review Sreality's terms, applicable database rights, copyright rules, and Czech/EU privacy law for your use case. Avoid republishing images or personal data without a lawful basis. Respect reasonable run frequency and do not use the Actor to harass advertisers or evade access controls.

This Actor is an independent automation tool and is not affiliated with Sreality.cz or Seznam.cz.

### FAQ

**Does the Actor support sale and rental listings?**

Yes. Supply the corresponding public Sreality search URL.

**Can I filter by region, district, layout, or property type?**

Yes. Configure those filters on Sreality and paste the resulting search URL. The Actor preserves the URL's public filter state.

**Can I monitor price changes?**

Yes, by scheduling recurring runs and comparing `priceCzk` for the same `listingId`. The Actor exports snapshots; it does not maintain history internally.

**Does it download images?**

No. It exports image URLs, which keeps runs lightweight and avoids media-transfer cost.

**Does it scrape listing detail pages?**

No. The product intentionally exports fields available from search results for efficient inventory monitoring.

**Are empty results charged?**

The one-time start event applies, but only unique saved records generate item events.

### Related Automation Lab Actors

For broader property workflows, see:

- [ImmoScout24 Property Listings Scraper](https://apify.com/automation-lab/immoscout24-property-scraper) for German property listings;
- [Fotocasa Property Listings Scraper](https://apify.com/automation-lab/fotocasa-property-listings-scraper) for Spanish listings;
- [RE/MAX Spain Property Listings Scraper](https://apify.com/automation-lab/remax-spain-property-listings-scraper) for RE/MAX Spain inventory.

Choose this Actor when your source is Sreality.cz and your job is efficient Czech sale/rental search-result monitoring.

# Actor input Schema

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

One or more public Sreality.cz search-result URLs. Build transaction, property type, location, and other filters on Sreality, then paste the resulting URLs here.

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

Maximum number of unique property listings saved across all search URLs.

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

Maximum attempts for temporary rate limits or server errors. Permanent input and page-format errors are not retried.

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

Proxy settings. Apify's datacenter proxy is the default for stable cloud delivery; disable it only for direct local requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha"
    }
  ],
  "maxItems": 20,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open the normalized property listings in the overview dataset view.

# 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": [
        {
            "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sreality-cz-property-listings-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": [{ "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sreality-cz-property-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.sreality.cz/en/search/for-sale/apartments/praha"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/sreality-cz-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/sreality-cz-property-listings-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0jRDrqa9EAK1Goe38/builds/QfhTw8nfr1l5b1mXF/openapi.json