# Sreality Palindrom Scraper (`janmatejka/palindrom`) Actor

Scrape property listings from Sreality.cz - Czech Republic's largest real estate portal. Paste a search URL with filters and get structured JSON of every listing.

- **URL**: https://apify.com/janmatejka/palindrom.md
- **Developed by:** [SilentService, s.r.o.](https://apify.com/janmatejka) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Sreality Palindrom Scraper

**Extract structured property listings from [Sreality.cz](https://www.sreality.cz)** - Czech Republic's largest real estate portal - straight from a search URL.

Paste the URL of any Sreality search (with all your filters applied) and this Actor returns a clean JSON dataset of every matching listing. The actor uses Sreality's own JSON API directly, so it does not parse HTML or rely on DOM selectors. That makes it resilient to cosmetic redesigns - if Sreality changes how their search URL maps to filters, the actor still picks up the change automatically because it reads Sreality's own filter state from the page. The actor will need an update only if Sreality replaces or renames their JSON API.

### What does Sreality Palindrom Scraper do?

- Reads the **search URL** you paste (e.g. `https://www.sreality.cz/hledani/prodej/byty/praha?cena-do=8000000`).
- Detects all your filters automatically (offer type, category, locality, price range, disposition, year built, energy class, etc.) by reading Sreality's own filter state.
- Paginates the JSON API to extract every matching listing.
- Optionally fetches each listing's **detail page** for description, full attributes, broker contact, and the complete image gallery.
- Outputs everything to an Apify Dataset that you can download as JSON, CSV, Excel, HTML, or stream via the Apify API.

### Why use Sreality Palindrom Scraper?

- **Real estate market analysis** - track price/m² across Prague districts, watch supply per disposition, monitor new-build vs. resale ratios.
- **Investment screening** - pull every 2+kk under 6 M Kč in Brno, filter by yield, get broker contacts in one CSV.
- **Lead generation for agencies** - extract listings from competitors and identify private sellers.
- **Comparable sales / valuations** - feed listings into your appraisal model with consistent fields.
- **Schedule it** - run the scraper hourly/daily on Apify and pipe results to Google Sheets, Slack, or your CRM via webhooks.

### How to use Sreality Palindrom Scraper

1. Open [Sreality.cz](https://www.sreality.cz) and apply your filters in the search UI (location, price, disposition, etc.).
2. Copy the URL from your browser address bar.
3. Paste it into this Actor's **Sreality search URL** input.
4. (Optional) Set **Max number of listings** (`0` = unlimited) and toggle **Fetch detail pages** if you need full descriptions and contacts.
5. Click **Start**. The dataset populates as listings are scraped.

### Input

The actor accepts a JSON input with the following fields. The Apify Console renders these as a friendly form.

Provide **one** of: `searchUrl`, `apiParams`, or `city`.

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchUrl` | string | - | Any Sreality search URL - filters detected automatically. |
| `city` | string | - | Free-text city/district/street (e.g. `Praha`, `Praha 6`, `Brno-Bystrc`). Resolved via Sreality's suggest API; accents and spelling variants handled automatically. Combine with `category` and `offerType`. |
| `category` | string | `""` | Enum: `byty`, `domy`, `pozemky`, `komercni`, `ostatni`. Used with `city`. |
| `offerType` | string | `""` | Enum: `prodej`, `pronajem`, `drazba`. Used with `city`. |
| `apiParams` | object | - | **Advanced**: snake_case Sreality API params (e.g. `{"category_main_cb":1,"locality_region_id":10}`). Skips the HTML bootstrap entirely - saves ~725 KB and one HTTP request per run. Ideal for cron-driven repeat polls of a known filter. |
| `sort` | string | `""` | Override search ordering. One of `-date` (newest first), `+date`, `-price_norm` (most expensive first), `+price_norm`. Empty keeps the existing ordering. |
| `maxResults` | integer | `100` | Hard cap. `0` = unlimited (capped internally at 100 000 for safety). |
| `includeDetails` | boolean | `false` | Adds description, full attributes, broker contact, POI distances. Slower and more bandwidth. |
| `pageSize` | integer | `500` | Search-page size. 500 is Sreality's max. |
| `detailConcurrency` | integer | `10` | Parallel detail-page requests when `includeDetails` is on. |
| `resumeFromLastRun` | boolean | `false` | Persist `{page, scraped}` to the actor's key-value store after every page. A subsequent run with the same filter resumes from the next unscraped page. Recommended for runs of 10 000+ listings. |
| `enableHistory` | boolean | `false` | Track price history across runs. Adds `isNew`, `priceChanged`, `previousPriceCzk`, `daysTracked`, `firstSeenAt` to every output record. Schedule the actor and the history accumulates. |
| `historyStoreId` | string | - | Name of a shared Apify Key-Value Store for history. Useful when multiple cron tasks watch different filters of the same property pool. Empty = the actor's own KVS. |
| `proxyConfiguration` | object | Apify residential | Standard Apify proxy picker. |
| `useDecodoProxy` | boolean | `false` | Bring-your-own Decodo / Smartproxy. |
| `decodoEndpoint` | string (secret) | - | Full proxy URL `http://user:pass@host:port`. URL-encode special characters. |

Example input:

```json
{
    "searchUrl": "https://www.sreality.cz/hledani/prodej/byty/praha?cena-od=3000000&cena-do=8000000",
    "maxResults": 1000,
    "includeDetails": false
}
````

### Output

Each listing becomes one record in the dataset. Example (search-only mode):

```json
{
    "id": 1580314700,
    "url": "https://www.sreality.cz/detail/prodej/byt/2+kk/praha-modrany-pirinska/1580314700",
    "apiUrl": "https://www.sreality.cz/api/cs/v2/estates/1580314700",
    "title": "Prodej bytu 2+kk 41 m²",
    "priceCzk": 6990000,
    "priceUnit": "",
    "priceText": "Celková cena",
    "priceHidden": false,
    "pricePerSqm": 170488,
    "areaM2": 41,
    "category": "byty",
    "subtype": "2+kk",
    "subtypeId": 4,
    "offerType": "prodej",
    "localityRaw": "Pirinská 12, Praha 4 - Modřany",
    "street": "Pirinská",
    "houseNumber": "12",
    "city": "Praha 4",
    "district": "Modřany",
    "gps": { "lat": 50.007881, "lon": 14.426118 },
    "image": "https://d18-a.sdn.cz/.../430b.jpeg?fl=res,400,300,3|jpg,90",
    "images": ["https://...", "https://..."],
    "imageCount": 15,
    "hasVideo": false,
    "hasPanorama": false,
    "hasFloorPlan": true,
    "isAuction": false,
    "isNew": false,
    "labels": ["panel", "elevator"],
    "agentName": "Myšák reality",
    "agentId": 21763,
    "agentLogo": "https://d48-a.sdn.cz/.../wAZCcY.png",
    "agentUrl": "https://www.sreality.cz/adresar/mysak-reality/21763",
    "scrapedAt": "2026-05-06T08:10:07.066Z"
}
```

With `includeDetails: true`, the record additionally contains:

```json
{
    "description": "Nabízíme k prodeji světlý byt 2+kk ...",
    "attributes": {
        "Stavba": "Cihlová",
        "Stav objektu": "Velmi dobrý",
        "Energetická náročnost budovy": "B - Velmi úsporná",
        "Vlastnictví": "Osobní",
        "Užitná plocha": "41 m²",
        "Sklep": true,
        "Výtah": true
    },
    "sellerName": "Jiří Maštálka",
    "sellerPhones": [{"code": "420", "type": "MOB", "number": "608444111"}],
    "sellerEmail": "jiri@example.cz",
    "poiTransportDistanceM": 64,
    "poiSchoolDistanceM": 326,
    "poiGroceryDistanceM": 420,
    "poiDoctorsDistanceM": 362,
    "poiRestaurantDistanceM": 192,
    "poiLeisureDistanceM": 601
}
```

You can download the dataset in JSON, CSV, Excel, or HTML directly from the Apify Console, or fetch it via the Apify API.

### Data fields

| Field | Type | Description |
|---|---|---|
| `id` | integer | Sreality's permanent listing ID. |
| `url` | string | Public Sreality listing URL. |
| `title` | string | Listing headline (auto-generated by Sreality). |
| `priceCzk` | integer or null | Price in CZK. `null` if the broker hides it ("price on request"). |
| `priceUnit` | string | `""` for sales (total price), `"za měsíc"` for rentals. **Always check this when scraping rentals - the number alone is monthly, not total.** |
| `priceText` | string | Sreality's display label for the price (usually `"Celková cena"`). |
| `priceHidden` | boolean | True when the broker hides the price. |
| `pricePerSqm` | integer or null | Precomputed `priceCzk / areaM2` (rounded). `null` when price is hidden or area is unknown. |
| `areaM2` | integer or null | Area in m² parsed from the title. |
| `category` | string | `byty`, `domy`, `pozemky`, `komercni`, `ostatni`. |
| `subtype` | string | Human-readable subtype: `"2+kk"`, `"rodinný dům"`, `"vila"`, `"sklad"`, etc. |
| `subtypeId` | integer | Sreality's numeric `category_sub_cb` for programmatic queries. |
| `offerType` | string | `prodej`, `pronajem`, or `drazba`. |
| `gps` | object | `{ lat, lon }`. |
| `images` | array | Full image gallery (public CDN URLs). |
| `agentName` | string or null | Realtor name when listing is brokered. |
| `agentUrl` | string or null | Public link to the agency profile (`sreality.cz/adresar/<slug>/<id>`). |
| `houseNumber` | string or null | Parsed from the street component (`Mostecká 12` -> `12`). Handles letters (`12a`) and slash forms (`3/5`). |
| `isNew` | boolean | (history mode) True when this listing wasn't seen in any prior run. |
| `priceChanged` | boolean | (history mode) True when the price differs from the last observation. Hidden-price transitions don't count. |
| `previousPriceCzk` | integer or null | (history mode) The prior observation's price when `priceChanged` is true. |
| `daysTracked` | integer | (history mode) Days since `firstSeenAt`. |
| `firstSeenAt` | string | (history mode) ISO timestamp of the first observation. Stable across all subsequent runs. |
| `description` | string | (details mode) Full listing description. |
| `attributes` | object | (details mode) All structured attributes shown on detail page. |
| `sellerPhones` | array | (details mode) Broker phone numbers. |
| `poiTransportDistanceM` | integer or null | (details mode) Closest public-transport stop in meters. |
| `poiSchoolDistanceM` | integer or null | (details mode) Closest school/kindergarten in meters. |
| `poiGroceryDistanceM` | integer or null | (details mode) Closest grocery store in meters. |
| `poiDoctorsDistanceM` | integer or null | (details mode) Closest medical facility in meters. |
| `poiRestaurantDistanceM` | integer or null | (details mode) Closest restaurant in meters. |
| `poiLeisureDistanceM` | integer or null | (details mode) Closest leisure-time POI in meters. |

### Pricing - how much does it cost to scrape Sreality?

Measured on a real run (2026-05-06, `pageSize=60` and sequential details; the v0.2 defaults of `pageSize=500` and `detailConcurrency=10` are faster):

| Mode | Bandwidth / 1k | Time / 1k | Apify CU / 1k @ 1 GB | Total cost / 1k (Apify proxy) |
|---|---|---|---|---|
| Search-only | ~7 MB | ~17 s | 0.005 CU | **~$0.06** |
| With details | ~76 MB | ~6.5 min (sequential) | 0.11 CU | **~$0.62** |

The actor accepts your **own Decodo / Smartproxy endpoint** if you want to bypass Apify's residential proxy and pay your own per-GB rate (typically $3 / GB for Decodo vs $8 / GB for Apify residential).

### Tips and advanced options

- **Filter at the URL level**, not after scraping. Sreality has 60+ filter fields (energy class, year built, ownership type, points-of-interest distance) - every one is supported automatically because the actor reads Sreality's own filter state.
- **Skip details for bulk runs.** With `includeDetails: false` the actor is ~10× faster and ~10× cheaper. Only enable details when you actually need descriptions or broker contacts.
- **Cap the run** with `maxResults` while you're iterating on filters to avoid burning credits on test runs.
- **Use `apiParams` for cron polling.** Once you've nailed your filter, capture the API params from a normal run's logs and paste them into `apiParams` for subsequent scheduled runs. The actor then skips the 725 KB HTML bootstrap and goes straight to the JSON API - lower bandwidth, one fewer HTTP request, faster start.
- **Skip the URL entirely with `city`.** For non-tech users: paste a city name (`Praha`, `Brno-Bystrc`, `Plzeň`) into the `city` field, pick `category` and `offerType` from the dropdowns, and you're done - no Sreality URL syntax to learn. The actor uses Sreality's own suggest API to resolve the locality.
- **Enable `resumeFromLastRun` for big jobs.** A 100 000-listing run takes ~30 minutes; if Apify aborts it mid-flight, the next invocation with the same filter picks up where it stopped instead of restarting from page 1.
- **Enable `enableHistory` for change tracking.** Schedule the actor (every 6h, daily, weekly) and each output record carries `isNew` / `priceChanged` / `previousPriceCzk` / `daysTracked`. Build alerts on price drops, monitor portfolios, measure time-on-market - the actor accumulates the timeline for you.
- **Schedule the actor** on Apify (every 6 h, daily, weekly) to track new listings and price changes over time. Combine with [Apify webhooks](https://docs.apify.com/platform/integrations/webhooks) to push deltas to your CRM, Slack, or Google Sheets.

### FAQ, disclaimers, and support

**Is scraping Sreality.cz legal?**
The actor reads only publicly accessible listings (no login, no paywall, no personal data outside what Sreality publishes itself). Use the data in compliance with Sreality's Terms of Service and applicable data-protection law (GDPR). The actor is provided as-is.

**Does it scrape historical / removed listings?**
No - only listings currently visible in your search.

**Does it scrape detail-page photos in full resolution?**
The `images` array contains the same CDN URLs Sreality serves to its own UI; you can request larger sizes by adjusting the URL `fl=res,W,H` parameter.

**Why are some `agentName` / `sellerPhones` fields null?**
Private sellers route contact via Sreality's anonymous form - Sreality does not expose their phone/email through the API, and neither does this actor.

**Found a bug or have a feature request?**
Open an issue on the actor's [Issues tab](https://apify.com/) on Apify Store, or contact the author directly.

**Need a custom solution?**
This actor focuses on standard Sreality search results. For custom requirements (Slovakia, Bazos.cz, multi-portal aggregation, change tracking, custom output format) reach out - happy to build it.

# Actor input Schema

## `searchUrl` (type: `string`):

Paste the full URL from sreality.cz with all your filters applied. The actor detects category, locality, price range and other filters automatically by reading Sreality's own filter state. Leave empty if you provide City or API params instead.

## `city` (type: `string`):

Free-text Czech city, district or street (e.g. 'Praha', 'Praha 6', 'Brno-Bystrc', 'Plzeň'). Resolved via Sreality's own suggest API, so accents and spelling variants are handled automatically. Combine with Category and Offer type below. Ignored if Search URL is also set.

## `category` (type: `string`):

Property category to search. Used only with City; otherwise the category comes from Search URL or API params.

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

Sale, rent or auction. Used only with City.

## `sort` (type: `string`):

Override the sort order of search results. Leave empty to use whatever the search URL specifies (default: newest first).

## `apiParams` (type: `object`):

Skip the HTML bootstrap and call Sreality's JSON API directly with these snake\_case params (e.g. {"category\_main\_cb":1,"category\_type\_cb":1,"locality\_region\_id":10}). When provided, searchUrl is ignored. Saves ~725 KB and one HTTP request per run, useful for cron-driven repeat polls.

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

Hard cap on how many listings to scrape. Set to 0 for unlimited (the actor enforces an internal safety cap of 100 000).

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

If enabled, the actor fetches each listing's detail page (description, broker contact, full attributes). Detail calls run concurrently (see Detail concurrency below) but will still take longer than search-only.

## `pageSize` (type: `integer`):

Number of listings to fetch per search request. 500 is the maximum Sreality accepts; lower it (e.g. 60) to reduce response size at the cost of more requests.

## `detailConcurrency` (type: `integer`):

How many detail-page requests to run in parallel. Higher = faster but increases the chance of being rate-limited. Only used when 'Fetch detail pages' is on.

## `resumeFromLastRun` (type: `boolean`):

Persist progress (page number, count) into the actor's key-value store after each page. If a run crashes or gets aborted, the next invocation with the same filter resumes from the next unscraped page. Disabled by default - opt in only for long runs (10k+ listings) where restarting from scratch would burn meaningful credits.

## `enableHistory` (type: `boolean`):

Persist a `{listingId -> {firstSeenAt, lastPriceCzk}}` map across runs. Each output record then carries `isNew`, `priceChanged`, `previousPriceCzk`, `daysTracked`, `firstSeenAt` - the killer feature for monitoring portfolios, watching for price drops, or measuring time-on-market. Schedule the actor and the history accumulates run by run.

## `historyStoreId` (type: `string`):

Optional name of an Apify Key-Value Store to share history across multiple actor configurations (e.g. different cron jobs polling different filters of the same property pool). Leave empty to use the actor's own KVS. Note: 9 MB per key limit caps stored history at roughly 50-80k listings per store.

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

Apify proxy settings. Residential is the safest choice; datacenter usually works for Sreality but has higher block risk.

## `useDecodoProxy` (type: `boolean`):

Bring-your-own-proxy. If enabled, the proxy URL below is used instead of the Apify proxy. Useful when you already pay Decodo / Smartproxy and want to control bandwidth costs separately.

## `decodoEndpoint` (type: `string`):

Full proxy URL with credentials, e.g. http://user:pass@gate.decodo.com:7000. URL-encode special characters in the password. Only used when 'Use Decodo' is on.

## Actor input object example

```json
{
  "searchUrl": "https://www.sreality.cz/hledani/prodej/byty/praha",
  "category": "",
  "offerType": "",
  "sort": "",
  "maxResults": 100,
  "includeDetails": false,
  "pageSize": 500,
  "detailConcurrency": 10,
  "resumeFromLastRun": false,
  "enableHistory": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "useDecodoProxy": false
}
```

# 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 = {
    "searchUrl": "https://www.sreality.cz/hledani/prodej/byty/praha"
};

// Run the Actor and wait for it to finish
const run = await client.actor("janmatejka/palindrom").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 = { "searchUrl": "https://www.sreality.cz/hledani/prodej/byty/praha" }

# Run the Actor and wait for it to finish
run = client.actor("janmatejka/palindrom").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 '{
  "searchUrl": "https://www.sreality.cz/hledani/prodej/byty/praha"
}' |
apify call janmatejka/palindrom --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sreality Palindrom Scraper",
        "description": "Scrape property listings from Sreality.cz - Czech Republic's largest real estate portal. Paste a search URL with filters and get structured JSON of every listing.",
        "version": "1.4",
        "x-build-id": "WkV0bDD4Z5LTTTsWa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/janmatejka~palindrom/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-janmatejka-palindrom",
                "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/janmatejka~palindrom/runs": {
            "post": {
                "operationId": "runs-sync-janmatejka-palindrom",
                "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/janmatejka~palindrom/run-sync": {
            "post": {
                "operationId": "run-sync-janmatejka-palindrom",
                "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": {
                    "searchUrl": {
                        "title": "Sreality search URL",
                        "pattern": "^https?://(www\\.)?sreality\\.cz/.+",
                        "type": "string",
                        "description": "Paste the full URL from sreality.cz with all your filters applied. The actor detects category, locality, price range and other filters automatically by reading Sreality's own filter state. Leave empty if you provide City or API params instead."
                    },
                    "city": {
                        "title": "City or locality (alternative to URL)",
                        "type": "string",
                        "description": "Free-text Czech city, district or street (e.g. 'Praha', 'Praha 6', 'Brno-Bystrc', 'Plzeň'). Resolved via Sreality's own suggest API, so accents and spelling variants are handled automatically. Combine with Category and Offer type below. Ignored if Search URL is also set."
                    },
                    "category": {
                        "title": "Category (when using City)",
                        "enum": [
                            "",
                            "byty",
                            "domy",
                            "pozemky",
                            "komercni",
                            "ostatni"
                        ],
                        "type": "string",
                        "description": "Property category to search. Used only with City; otherwise the category comes from Search URL or API params.",
                        "default": ""
                    },
                    "offerType": {
                        "title": "Offer type (when using City)",
                        "enum": [
                            "",
                            "prodej",
                            "pronajem",
                            "drazba"
                        ],
                        "type": "string",
                        "description": "Sale, rent or auction. Used only with City.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "",
                            "-date",
                            "+date",
                            "-price_norm",
                            "+price_norm"
                        ],
                        "type": "string",
                        "description": "Override the sort order of search results. Leave empty to use whatever the search URL specifies (default: newest first).",
                        "default": ""
                    },
                    "apiParams": {
                        "title": "Direct API params (advanced)",
                        "type": "object",
                        "description": "Skip the HTML bootstrap and call Sreality's JSON API directly with these snake_case params (e.g. {\"category_main_cb\":1,\"category_type_cb\":1,\"locality_region_id\":10}). When provided, searchUrl is ignored. Saves ~725 KB and one HTTP request per run, useful for cron-driven repeat polls."
                    },
                    "maxResults": {
                        "title": "Max number of listings",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on how many listings to scrape. Set to 0 for unlimited (the actor enforces an internal safety cap of 100 000).",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "If enabled, the actor fetches each listing's detail page (description, broker contact, full attributes). Detail calls run concurrently (see Detail concurrency below) but will still take longer than search-only.",
                        "default": false
                    },
                    "pageSize": {
                        "title": "Search page size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Number of listings to fetch per search request. 500 is the maximum Sreality accepts; lower it (e.g. 60) to reduce response size at the cost of more requests.",
                        "default": 500
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many detail-page requests to run in parallel. Higher = faster but increases the chance of being rate-limited. Only used when 'Fetch detail pages' is on.",
                        "default": 10
                    },
                    "resumeFromLastRun": {
                        "title": "Resume from last run if it crashed",
                        "type": "boolean",
                        "description": "Persist progress (page number, count) into the actor's key-value store after each page. If a run crashes or gets aborted, the next invocation with the same filter resumes from the next unscraped page. Disabled by default - opt in only for long runs (10k+ listings) where restarting from scratch would burn meaningful credits.",
                        "default": false
                    },
                    "enableHistory": {
                        "title": "Track price history across runs",
                        "type": "boolean",
                        "description": "Persist a `{listingId -> {firstSeenAt, lastPriceCzk}}` map across runs. Each output record then carries `isNew`, `priceChanged`, `previousPriceCzk`, `daysTracked`, `firstSeenAt` - the killer feature for monitoring portfolios, watching for price drops, or measuring time-on-market. Schedule the actor and the history accumulates run by run.",
                        "default": false
                    },
                    "historyStoreId": {
                        "title": "Named key-value store for shared history",
                        "type": "string",
                        "description": "Optional name of an Apify Key-Value Store to share history across multiple actor configurations (e.g. different cron jobs polling different filters of the same property pool). Leave empty to use the actor's own KVS. Note: 9 MB per key limit caps stored history at roughly 50-80k listings per store."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential is the safest choice; datacenter usually works for Sreality but has higher block risk.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "useDecodoProxy": {
                        "title": "Use Decodo (BYOP) instead of Apify proxy",
                        "type": "boolean",
                        "description": "Bring-your-own-proxy. If enabled, the proxy URL below is used instead of the Apify proxy. Useful when you already pay Decodo / Smartproxy and want to control bandwidth costs separately.",
                        "default": false
                    },
                    "decodoEndpoint": {
                        "title": "Decodo proxy URL",
                        "type": "string",
                        "description": "Full proxy URL with credentials, e.g. http://user:pass@gate.decodo.com:7000. URL-encode special characters in the password. Only used when 'Use Decodo' is on."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
