# Bezrealitky Scraper - Czech Real Estate Listings (`studio-amba/bezrealitky-scraper`) Actor

Scrape Bezrealitky.cz Czech no-agent real estate listings: prices, disposition, surface, GPS, address, images and energy label. Covers sale and rent, apartments, houses and land nationwide.

- **URL**: https://apify.com/studio-amba/bezrealitky-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Features:** Limited permissions
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### What does Bezrealitky Scraper do?

**Bezrealitky Scraper** extracts real estate listings from [Bezrealitky.cz](https://www.bezrealitky.cz) — the largest no-agent-commission property portal in Czechia. It collects **prices, disposition (room layout), surface area, GPS coordinates, address, images and energy labels** for apartments, houses and land, for sale or for rent, across any Czech city or region. No login or cookies required.

Use the Apify platform to run this scraper on a schedule, access results via API, or integrate with tools like Google Sheets, Slack, Zapier, and Make.

### Why use Bezrealitky Scraper?

- **Market research** — Track apartment and house prices across Czech cities, compare disposition types (1+kk, 2+1, 3+kk, etc.), and spot price trends
- **Lead generation** — Bezrealitky is a no-agent marketplace, so listings often come straight from private owners — useful for relocation services, mortgage brokers, and renovation companies
- **Price monitoring** — Schedule recurring runs to track price changes on a city or region over time
- **Data analysis** — Export structured data to CSV, JSON, or Excel for portfolio or market analysis
- **Relocation planning** — Compare rents and sale prices across Prague, Brno, Ostrava and smaller cities
- **Investment screening** — Filter by disposition and surface to find undervalued listings in a target neighborhood

### How to scrape bezrealitky data

1. Go to the [Bezrealitky Scraper](https://apify.com/jelledesramaults/bezrealitky-scraper) page on Apify
2. Click **Try for free** to open the actor in Apify Console
3. Choose **Transaction Type**: for sale (`prodej`) or for rent (`pronajem`)
4. Optionally pick a **Property Type**: apartment (`byt`), house (`dum`), or land (`pozemek`). Leave empty to search both apartments and houses
5. Optionally enter a **City / Region** slug, e.g. `praha`, `brno`, `ostrava` — the same slug bezrealitky.cz uses in its own URLs. Leave empty to search the whole country
6. Toggle **Fetch full details** on if you need the full description, all images and the energy label (PENB) — this costs one extra request per listing
7. Set **Max Results** to the number of listings you need
8. Click **Start** and wait for the scraper to finish
9. Download your data in JSON, CSV, Excel, or HTML format

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `transaction` | String | No | `prodej` (for sale, default) or `pronajem` (for rent) |
| `estateType` | String | No | `byt` (apartment), `dum` (house), or `pozemek` (land). Leave empty to search both apartments and houses |
| `regionUri` | String | No | City/region slug, e.g. `praha`, `brno`, `ostrava`. Leave empty to search nationwide |
| `fetchDetails` | Boolean | No | Fetch full description, all images and energy label per listing (default: false, costs one extra request per item) |
| `maxResults` | Integer | No | Maximum listings to return (default: 100) |
| `proxyConfiguration` | Object | No | Proxy settings. Bezrealitky has no anti-bot protection, so the default Apify proxy works fine |

### Output

Each listing contains:

| Field | Type | Example |
|-------|------|---------|
| `advertId` | String | `"1033989"` |
| `adTitle` | String | `"Prodej bytu 1+kk 28 m²"` (only with `fetchDetails`) |
| `transaction` | String | `"PRODEJ"` |
| `estateType` | String | `"BYT"` |
| `price` | Number | `5400000` |
| `currency` | String | `"CZK"` |
| `charges` | Number | `0` |
| `disposition` | String | `"DISP_1_KK"` |
| `surface` | Number | `28` |
| `address` | String | `"Ohradní, Praha - Michle"` |
| `city` | String | `"Praha"` |
| `region` | String | `null` (bezrealitky's address string does not expose the CZ administrative region) |
| `lat` | Number | `50.0522473` |
| `lng` | Number | `14.4554874` |
| `listingDescription` | String | Full listing text (only with `fetchDetails`) |
| `images` | Array | Up to 5 image URLs |
| `energyLabel` | String | `"A - mimořádně úsporná"` (only with `fetchDetails`) |
| `url` | String | Full listing URL on Bezrealitky |
| `scrapedAt` | String | `"2026-07-12T22:45:30.988Z"` |

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Example output

```json
{
    "advertId": "1033989",
    "transaction": "PRODEJ",
    "estateType": "BYT",
    "price": 5400000,
    "currency": "CZK",
    "charges": 0,
    "disposition": "DISP_1_KK",
    "surface": 28,
    "address": "Ohradní, Praha - Michle",
    "city": "Praha",
    "lat": 50.0522473,
    "lng": 14.4554874,
    "images": [
        "https://api.bezrealitky.cz/media/cache/record_main/data/images/advert/1033k/1033989/...jpg",
        "https://api.bezrealitky.cz/media/cache/record_main/data/images/advert/1033k/1033989/...jpg"
    ],
    "url": "https://www.bezrealitky.cz/nemovitosti-byty-domy/1033989-nabidka-prodej-bytu-ohradni-praha",
    "scrapedAt": "2026-07-12T22:45:30.988Z"
}
```

### How much does it cost to scrape Bezrealitky?

Bezrealitky runs an open GraphQL API with no anti-bot protection, so this is a lightweight, fast HTTP actor — no browser rendering involved. It charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result:

- **~20 listings** per run: about $0.06, a few seconds
- **~500 listings** per run: about $1.02, under a minute
- **Full city catalogue with `fetchDetails`** (e.g. Prague, ~2,000 sale listings): about $4.02, a few minutes -- `fetchDetails` roughly doubles the number of requests but not the per-result price

This is one of the cheapest actors in the catalogue to run at scale. A run's usage cost only settles after it reports SUCCEEDED.

### Limitations

- `adTitle`, `listingDescription` and `energyLabel` are only populated when `fetchDetails` is enabled — the listing-level API does not expose them
- `region` (the Czech administrative kraj) is not available in bezrealitky's address string and is left empty rather than guessed
- Data is scraped from the public bezrealitky.cz GraphQL API and may change without notice
- Respect the website's terms of service and use responsibly

### Related Scrapers

Looking for real estate data elsewhere in Europe? Check out:

- **Sreality Scraper** — the other major Czech real estate portal (Seznam's listings, including agency-listed properties bezrealitky excludes by design)
- **Imot.bg Scraper** — Bulgaria's leading real estate marketplace
- **Zimmo Scraper** — Belgian real estate listings

**Sibling opportunity:** bezrealitky.sk runs the identical GraphQL platform for the Slovak market but has not been built as a separate actor yet — reach out if you need Slovak coverage.

### FAQ and support

**Is it legal to scrape Bezrealitky?**
This actor extracts publicly available data from bezrealitky.cz. Users are responsible for ensuring their use complies with applicable laws and the website's terms of service.

**Why are some fields empty?**
Not every listing has every detail (e.g., charges, energy label). `adTitle`, `listingDescription` and `energyLabel` specifically require `fetchDetails: true`.

**The scraper returned 0 results?**
Check that `regionUri` is a valid bezrealitky city/region slug (e.g. `praha`, not `prague`). Leave it empty to search the whole country if unsure.

**Can I filter by price or number of rooms?**
Not yet in this version — the actor currently filters by transaction type, property type and region. Open an issue if you need price or disposition filters added.

**Need a custom solution?**
If something breaks or you need an extra field, open an issue on the [Issues tab](https://apify.com/jelledesramaults/bezrealitky-scraper/issues).

# Actor input Schema

## `transaction` (type: `string`):

Whether to scrape listings for sale or for rent.

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

Filter by property type. Leave empty to include both apartments and houses (default nationwide scope).

## `regionUri` (type: `string`):

City or region slug to scope the search, e.g. 'praha', 'brno', 'ostrava' (same slug as used in bezrealitky.cz URLs). Resolved to a region ID via the site's own region lookup. Leave empty to search nationwide.

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

Fetch one extra GraphQL call per listing for the full description, all images and formatted parameters (condition, ownership, construction, PENB energy class, floors, available from). Roughly doubles the number of requests and run time — on a large maxResults this is a request multiplier, so the run uses migration-safe resume state.

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

Maximum number of listings to return.

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

Bezrealitky's GraphQL API has no anti-bot protection — Apify's default (auto/datacenter) proxy works fine.

## Actor input object example

```json
{
  "transaction": "prodej",
  "regionUri": "praha",
  "fetchDetails": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "transaction": "prodej",
    "regionUri": "praha",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/bezrealitky-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 = {
    "transaction": "prodej",
    "regionUri": "praha",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/bezrealitky-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 '{
  "transaction": "prodej",
  "regionUri": "praha",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/bezrealitky-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/bezrealitky-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/dsevPDiXvFA5hIgEF/builds/TrKsNAxsCDA4RVnkT/openapi.json