How to Scrape Sreality.cz Czech Real Estate Listings in 2026

Sreality.cz is the Czech Republic’s dominant property portal — the default place to list and find apartments, houses, land, and commercial space from Prague to Brno. For anyone doing Czech market research, investment screening, or agency tracking, it’s the dataset. And here’s the good news compared to many real estate portals: Sreality exposes a clean, public JSON API. There’s no enterprise anti-bot wall to fight, no browser to launch. The work is in querying the endpoint with the right filters, paginating without looping forever, and mapping the records into something analyzable. This guide covers all of it.

The public JSON API

Sreality’s website is a SPA that talks to a documented-by-behavior REST endpoint:

https://www.sreality.cz/api/cs/v2/estates
  ?category_main_cb=1          # 1=apartments, 2=houses, 3=land, 4=commercial...
  &category_type_cb=1          # 1=sale, 2=rent, 3=auction
  &locality_region_id=10       # region filter (10=Prague)
  &czk_price_from=2000000
  &czk_price_to=8000000
  &per_page=60
  &page=1

Hit it and you get back a JSON object with an _embedded.estates array — the same listings the front-end renders, fully structured. Because it’s a direct JSON request, there’s no headless browser and no anti-bot bypass required. This is the cheap, fast end of the scraping spectrum, much closer to the Shopify /products.json model than to the browser-warming gymnastics that Greek or aggressively-defended portals demand.

The filter parameters are the power here. You can slice by:

• category_main_cb — apartments, houses, land, commercial.
• category_type_cb — sale, rent, or auction (the auction filter is gold for foreclosure tracking).
• Region and locality — by region ID.
• czk_price_from / czk_price_to — price band in Czech koruna.
• Usable area and land area — size ranges.
• Sort order — including newest-first for daily new-listings feeds.

What each estate record contains

Mapping the embedded estate objects yields a flat, analyzable record:

• Identity — unique listing ID, the API endpoint URL for the detail record.
• Classification — title, main category, transaction type, subtype code.
• Pricing — numeric price, a human-formatted price string, currency (CZK), and a computed price per area (CZK/m²).
• Size — usable area and, for plots, land area.
• Locality — parsed into city, district, and region components.
• Geography — GPS latitude/longitude.
• Media — main image plus gallery URLs and image counts; flags for floorplan, video, and 3D tour presence.
• Provenance — agent/agency identifiers and branding, raw API labels/tags, and scrape timestamps.

The CZK/m² and the media-presence flags are the standouts — they let you build price heatmaps and filter for listings with proper photo coverage versus thin ads.

Pagination without infinite loops

The one non-obvious gotcha: Sreality’s API will happily keep serving pages past the real end of the result set, sometimes repeating the last page. Naive while (true) page++ logic loops forever. The fix is loop detection by comparing listing IDs across pages — if page N returns the same IDs as page N-1, you’ve hit the end and stop. A well-built scraper does this automatically; if you build your own, it’s the bug you’ll hit first.

Optional proxy support exists for sustained large pulls, but for normal volumes the API tolerates direct requests fine.

▶ Run the Sreality.cz Scraper — extracts Czech property listings via the direct JSON API: price in CZK, CZK/m², GPS, locality, agency and image gallery. Filter by region, category, price and area. No browser needed.

Schema design for downstream use

A clean per-listing record:

{
  "listing_id": "3847562910",
  "url": "https://www.sreality.cz/api/cs/v2/estates/3847562910",
  "title": "Prodej bytu 3+kk 78 m²",
  "category": "apartment",
  "transaction": "sale",
  "subtype": "3+kk",
  "price_czk": 6450000,
  "price_formatted": "6 450 000 Kč",
  "currency": "CZK",
  "price_per_sqm": 82692,
  "usable_area_sqm": 78,
  "land_area_sqm": null,
  "city": "Praha",
  "district": "Praha 4",
  "region": "Hlavní město Praha",
  "lat": 50.043,
  "lng": 14.451,
  "image_count": 12,
  "main_image": "https://d18-a.sdn.cz/.../main.jpg",
  "has_floorplan": true,
  "has_video": false,
  "has_3d": false,
  "agency_id": "company-58210",
  "scraped_at": "2026-06-01T12:00:00Z"
}

Choices worth making early:

• Keep both price_czk and price_formatted. The numeric field is for math; the formatted string preserves the portal’s exact display, useful for QA.
• Store price_per_sqm directly. Use the computed comparable rather than recomputing and risking rounding drift.
• Split locality into city/district/region. Czech analytics live at the district level (Praha 1 vs Praha 9 are different markets); a single concatenated string is hard to group on.
• Keep the media flags. Listings with floorplans/3D tours convert and price differently — a useful quality signal.

Typical use cases

• Market research — CZK/m² heatmaps by region, district, and subtype across the whole country.
• Investment screening — pair rent and sale data per area to estimate yields.
• Lead generation — discover and cluster active agencies via agent identifiers.
• Price tracking — periodic re-scrapes to detect price changes and follow a listing’s lifecycle.
• Auction monitoring — filter category_type_cb to auctions to track foreclosure inventory.
• Land scouting — search plots by land category and land-area ranges.
• New-listings feed — sort newest-first and limit pages for a clean daily feed of fresh listings.

The common thread is structured comparability at low cost — because the API is open, you can afford to refresh broadly and often.

Cost math

This actor charges a tiny per-run start fee and effectively free per-result extraction. With no browser and no mandatory proxy, the compute footprint is minimal. A realistic workflow — all Prague apartments for sale, refreshed daily — is a few thousand listings per run and sits inside Apify’s free monthly credit for most users; a country-wide multi-category sweep still lands in the low single digits of dollars per month.

Building it yourself is genuinely approachable here (it’s a public JSON API), but you’d still own:

• The filter-parameter mapping (the _cb codes are not self-documenting).
• The loop-detection pagination that stops at the true end.
• Locality parsing and CZK/m² computation.
• A scheduler and dedupe layer for recurring runs.

It’s a “you could, but why” situation — the API is friendly, but the upkeep is still yours.

Common pitfalls

• Infinite pagination. Without ID-based loop detection, the API will spin you forever. This is the number-one DIY bug.
• Misreading the category codes. category_main_cb and category_type_cb are numeric and order-sensitive; mixing up sale/rent silently returns the wrong dataset.
• Mixing transaction types. As with any property market, never blend rent and sale prices in one statistic.
• Currency. Everything is CZK. If you’re benchmarking against EUR markets, convert downstream and store the rate you used.
• Locality as one string. Parse city/district/region up front or regret it at analysis time.
• Over-polling. The API is open but not infinite. Space large pulls and use proxies for sustained sweeps.

Wrapping up

Sreality is the rare real estate portal that hands you a clean public JSON API instead of an anti-bot wall — which makes Czech property data unusually cheap to collect at breadth. The only real traps are the cryptic filter codes and the pagination loop. Write the fetch loop yourself for a one-off analysis, or lean on a managed actor that already handles the loop detection, locality parsing, and scheduling when you want a recurring Czech market feed.

▶ Open the Sreality.cz scraper on Apify — direct JSON API access, CZK/m², GPS, locality, agency and galleries, with safe loop-detecting pagination. Pay per result. Start with Apify’s free monthly credit.