# Morizon.pl Property Scraper (`solidcode/morizon-pl-scraper`) Actor

\[💰 $3.0 / 1K] Extract Polish real-estate listings from Morizon (morizon.pl) — sale and rent apartments, houses, plots, rooms, garages, commercial. Get price, area, rooms, location, GPS, building specs, condition, and agent contacts. Search by filters or paste URLs.

- **URL**: https://apify.com/solidcode/morizon-pl-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

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

## Morizon.pl Property Scraper

Pull Polish real-estate listings from Morizon (morizon.pl) at scale — sale and rental prices in PLN, price per m², GPS coordinates, building specs, seller and agent phone numbers, and full photo galleries for apartments, houses, plots, rooms, garages, and commercial units across all of Poland. Built for real-estate investors, relocation and expat-housing agencies, and PropTech and market-research teams who need structured Polish property data without clicking through morizon.pl one listing at a time.

### Why This Scraper?

- **6 property types in one actor** — apartments, houses, plots and land, rooms, garages, and commercial units, plus an "Any" mode that pulls every type in a single run.
- **Sale and rental markets, all of Poland** — flip one dropdown between for-sale (sprzedaż) and for-rent (wynajem); search any Polish city, or drill into a district like `krakow/stare-miasto`.
- **Street-level GPS on every listing** — precise latitude and longitude pulled from each property's detail map, ready to plot, geofence, or cluster.
- **Direct seller and agent phone numbers** — skip the contact form; each row carries the published phone number plus whether the seller is an agency, private owner, or developer, with agency and agent names.
- **Price per m² pre-computed** — every listing ships `pricePerM2` in PLN alongside the headline price and area, so you can rank by value without post-processing.
- **Building specifications** — year built, building type, construction material, heating, condition, market type (primary vs. secondary), bathroom count, and floor, pulled from the detail page.
- **Full photo galleries plus rich-media flags** — every image URL for a listing with a total photo count, plus boolean flags for listings that carry a 3D virtual tour (`has3dView`) or a video walkthrough (`hasVideo`).
- **Recency filter down to the last 24 hours** — capture only listings first posted within 1, 3, 7, 14, or 30 days to catch fresh inventory the moment it lists.
- **Fast bulk mode on demand** — turn off full details for a rapid price-and-location-only pull across thousands of listings when GPS and phones aren't needed.

### Use Cases

**Real-Estate Investment & Valuation**
- Rank neighborhoods by price per m² across cities and districts
- Track fresh sale listings within the last 24 hours to move on deals first
- Compare primary-market (new-build) versus secondary-market pricing
- Underwrite rental yields by pairing sale and rent pulls for the same district

**Relocation & Expat Housing**
- Build shortlists of rentals in a target city with room-count and area filters
- Map candidate homes by GPS against schools, offices, and transit
- Pull owner-listed rooms and apartments to skip agency fees where possible

**Market Research & Pricing Analysis**
- Measure asking-price trends by property type across Polish metros
- Analyze inventory mix (apartments vs. houses vs. plots) by region
- Benchmark price per m² between primary and secondary markets

**PropTech & Lead Generation**
- Feed structured listing data into your own valuation or search product
- Build agency and agent contact lists with published phone numbers
- Enrich a CRM with fresh listings, GPS, and seller type by district

**Data Integration & Enrichment**
- Keep an internal dashboard current with the latest Morizon inventory
- Attach photo galleries and building specs to existing property records
- Power alerting on new listings matching a saved filter set

### Getting Started

#### Search by City

The simplest run — apartments for sale in Warsaw:

```json
{
    "transactionType": "sprzedaz",
    "propertyType": "mieszkania",
    "location": "warszawa",
    "maxResults": 50
}
````

#### Filtered Rental Search

Two-to-three-room rental apartments in a Kraków district, posted in the last week:

```json
{
    "transactionType": "wynajem",
    "propertyType": "mieszkania",
    "location": "krakow/stare-miasto",
    "priceMax": 4000,
    "roomsMin": 2,
    "roomsMax": 3,
    "postedWithinDays": "7",
    "maxResults": 200
}
```

#### Advanced — Filters Plus Pasted URLs

Combine a guided budget-and-size search with a saved morizon.pl search URL and a single listing you want captured:

```json
{
    "transactionType": "sprzedaz",
    "propertyType": "domy",
    "location": "poznan",
    "priceMin": 500000,
    "priceMax": 1200000,
    "areaMin": 80,
    "startUrls": [
        "https://www.morizon.pl/mieszkania/wroclaw/",
        "https://www.morizon.pl/oferta/sprzedaz-mieszkanie-warszawa-mokotow-example"
    ],
    "maxResults": 500,
    "includeDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `transactionType` | select | `For Sale (sprzedaż)` | Collect properties for sale (sprzedaż) or for rent (wynajem). Ignored when Start URLs are provided. |
| `propertyType` | select | `Apartments (mieszkania)` | Property category: Any, Apartments (mieszkania), Houses (domy), Plots / Land (działki), Rooms (pokoje), Garages (garaże), or Commercial (nieruchomości komercyjne). |
| `location` | string | `warszawa` | City on its own (e.g. `warszawa`, `krakow`) for the whole city, or `city/district` (e.g. `krakow/stare-miasto`) to target a district. Leave empty to search all of Poland. |

#### Advanced Search (optional)

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste morizon.pl search-result or individual listing URLs. When provided, these override the transaction, property-type, location, and filter settings above; any filters already in the URL are preserved. |

#### Price, Rooms & Size

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | — | Minimum price in Polish złoty (PLN). Leave empty for no minimum. |
| `priceMax` | integer | — | Maximum price in Polish złoty (PLN). Leave empty for no maximum. |
| `areaMin` | integer | — | Minimum area in square metres. Leave empty for no minimum. |
| `areaMax` | integer | — | Maximum area in square metres. Leave empty for no maximum. |
| `roomsMin` | integer | — | Minimum number of rooms (1–10). Leave empty for no minimum. |
| `roomsMax` | integer | — | Maximum number of rooms (1–10). Leave empty for no maximum. |
| `postedWithinDays` | select | `Any time` | Only include listings first posted within: Any time, Last 24 hours, Last 3 days, Last 7 days, Last 14 days, or Last 30 days. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to collect across all searches and URLs combined. Set to 0 for as many as possible (up to a built-in safety cap). Start with 20–50 to test, then increase. |
| `includeDetails` | boolean | `true` | Open each listing's detail page to capture the full photo gallery, GPS coordinates, building specs, condition, market and ownership type, seller/agent name and phone, and the full description. Slower but much richer. When off, only result-page fields are returned. |

### Output

Each listing is one flat row. Here's a representative result with full details enabled:

```json
{
    "id": "mzn12345678",
    "url": "https://www.morizon.pl/oferta/sprzedaz-mieszkanie-warszawa-wilanow-franciszka-klimczaka-42m2-example",
    "title": "Przestronne 2-pokojowe mieszkanie, Wilanów",
    "transactionType": "sprzedaz",
    "propertyType": "mieszkania",
    "price": 950000,
    "priceCurrency": "PLN",
    "priceFormatted": "950 000 zł",
    "pricePerM2": 22619.05,
    "area": 42,
    "rooms": 2,
    "floor": "piętro 4/4",
    "voivodeship": "mazowieckie",
    "city": "Warszawa",
    "district": "Wilanów",
    "street": "Franciszka Klimczaka",
    "streetNumber": "17",
    "latitude": 52.15202,
    "longitude": 21.10499,
    "marketType": "Rynek wtórny",
    "reference": "MZ-0042-XY",
    "buildYear": 2015,
    "buildingType": "blok",
    "buildingMaterial": "cegła",
    "heating": "miejskie",
    "condition": "do zamieszkania",
    "numberOfBathrooms": 1,
    "features": ["balkon", "winda", "garaż", "monitoring"],
    "description": "Komfortowe mieszkanie w cichej części Wilanowa...",
    "sellerType": "AGENCY",
    "agencyName": "Przykładowa Nieruchomości Sp. z o.o.",
    "agentName": "Anna Kowalska",
    "sellerPhone": "602 206 111",
    "phones": ["602 206 111", "22 555 12 34"],
    "images": [
        "https://media.morizon.pl/big/example-1.jpg",
        "https://media.morizon.pl/big/example-2.jpg"
    ],
    "imageCount": 12,
    "addedAt": "28.06.2026",
    "refreshedAt": "2026-07-01 11:07:04",
    "updatedAt": "03.07.2026",
    "isPromoted": true,
    "has3dView": false,
    "hasVideo": true,
    "detailsLoaded": true,
    "scrapedAt": "2026-07-05T14:30:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Morizon listing identifier |
| `url` | string | Canonical listing URL |
| `title` | string | Listing headline |
| `transactionType` | string | `sprzedaz` (sale) or `wynajem` (rent) |
| `propertyType` | string | Property category slug |
| `description` | string | Listing description text |
| `addedAt` | string | Date the listing was first posted |
| `refreshedAt` | string | Date the listing was last refreshed on Morizon; present on every row |
| `isPromoted` | boolean | Whether the listing is promoted/featured |
| `has3dView` | boolean | Whether the listing includes a 3D virtual tour |
| `hasVideo` | boolean | Whether the listing includes a video walkthrough |
| `detailsLoaded` | boolean | Whether detail-page enrichment succeeded for this row |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Pricing & Size

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in PLN |
| `priceCurrency` | string | Currency code (PLN) |
| `priceFormatted` | string | Formatted price display string (e.g. "950 000 zł") |
| `pricePerM2` | number | Price per square metre in PLN |
| `area` | number | Area in square metres |
| `rooms` | number | Number of rooms |
| `floor` | string | Floor, as displayed (e.g. "piętro 4/4") |

#### Location & GPS

| Field | Type | Description |
|-------|------|-------------|
| `voivodeship` | string | Voivodeship (region) |
| `city` | string | City |
| `district` | string | District |
| `street` | string | Street name |
| `streetNumber` | string | Street number (detail mode) |
| `latitude` | number | GPS latitude (detail mode) |
| `longitude` | number | GPS longitude (detail mode) |

#### Building Details

Populated when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `marketType` | string | Primary or secondary market |
| `reference` | string | Listing reference code |
| `buildYear` | number | Year built |
| `buildingType` | string | Building type |
| `buildingMaterial` | string | Construction material |
| `heating` | string | Heating type |
| `condition` | string | Property condition |
| `numberOfBathrooms` | number | Bathroom count |
| `updatedAt` | string | Last-updated date from the detail page |
| `features` | string\[] | Amenities, equipment, and facility tags |

#### Seller & Media

| Field | Type | Description |
|-------|------|-------------|
| `sellerType` | string | AGENCY, private owner, or developer |
| `agencyName` | string | Agency name |
| `agentName` | string | Agent name |
| `sellerPhone` | string | Primary published phone number |
| `phones` | string\[] | All published phone numbers |
| `images` | string\[] | Full-resolution photo URLs |
| `imageCount` | number | Number of photos |

### Tips for Best Results

- **Start small to test** — set `maxResults` to 20–50 on your first run to confirm the fields match your needs, then scale up.
- **Target a district for tighter, richer results** — writing `krakow/stare-miasto` instead of just `krakow` narrows the pull and keeps you well inside Morizon's per-search listing window.
- **Split broad cities by budget or size** — a single filter set returns up to about 7,000 listings; for high-inventory metros like Warsaw, run several passes with different `priceMin`/`priceMax` bands to capture the full market without hitting that ceiling.
- **Turn off `includeDetails` for a fast bulk pull** — when you only need price, area, rooms, and city across thousands of listings, disabling details skips the per-listing detail fetch and returns results much faster; GPS, phones, and build year are omitted in that mode.
- **Use Start URLs for filters not in the guided form** — build any search on morizon.pl in your browser (sort order, extra filters), then paste that URL into `startUrls` — the filters baked into the URL are preserved exactly.
- **Combine a saved search URL with individual listing URLs** — mix a search-page URL and specific `/oferta/` listing URLs in one `startUrls` run to top up a bulk pull with hand-picked properties.
- **Catch fresh inventory** — set `postedWithinDays` to "Last 24 hours" and schedule daily runs to build a real-time feed of brand-new listings in your target area.

### Pricing

**From $3.00 per 1,000 results** — cleaner, cheaper, and richer than the alternatives for Polish property data. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is any listing row in the output dataset. The per-run start fee and any Apify platform fees are additional and depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate real-estate research, market analysis, relocation planning, and lead generation. You are responsible for complying with applicable laws and Morizon's Terms of Service. Do not use extracted contact details for spam, harassment, or any unlawful purpose, and handle any personal data in line with GDPR and other applicable privacy regulations. </content> </invoke>

# Actor input Schema

## `transactionType` (type: `string`):

Collect properties for sale (sprzedaż) or for rent (wynajem). Ignored when Start URLs are provided.

## `propertyType` (type: `string`):

Property category to search. Choose 'Any' to include all types. Ignored when Start URLs are provided.

## `location` (type: `string`):

Where to search. Enter a city on its own (e.g. 'warszawa', 'krakow') to cover the whole city. To target a district, add it after a slash — for example 'krakow/stare-miasto' or 'warszawa/mokotow'. Leave empty to search all of Poland. Ignored when Start URLs are provided.

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

Power-user input. Paste morizon.pl URLs directly — either search-result pages (e.g. https://www.morizon.pl/mieszkania/warszawa/) or individual listing pages. When provided, these override the For Sale/Rent, Property Type, Location, and all filter settings above; any filters already in the URL (price, area, rooms, sort) are preserved.

## `priceMin` (type: `integer`):

Only include listings at or above this price, in Polish złoty (PLN). Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only include listings at or below this price, in Polish złoty (PLN). Leave empty for no maximum.

## `areaMin` (type: `integer`):

Only include properties at or above this area, in square metres. Leave empty for no minimum.

## `areaMax` (type: `integer`):

Only include properties at or below this area, in square metres. Leave empty for no maximum.

## `roomsMin` (type: `integer`):

Only include properties with at least this many rooms. Leave empty for no minimum.

## `roomsMax` (type: `integer`):

Only include properties with at most this many rooms. Leave empty for no maximum.

## `postedWithinDays` (type: `string`):

Only include listings first posted within this many days. Choose 'Any time' for no recency limit.

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

Maximum number of listings to collect across all searches and URLs combined. Set to 0 for as many as possible (up to a built-in safety cap). Results are collected in full pages, so the final page may overshoot this cap by a few listings. Tip: start with 20-50 to test, then increase.

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

Open each listing's detail page to capture the full record — the whole photo gallery, map coordinates, building specs (type, material, year built, heating), condition, market and ownership type, seller/agent name and phone, and the full description. Slower but much richer. When off, only the fields shown on result pages are returned.

## Actor input object example

```json
{
  "transactionType": "sprzedaz",
  "propertyType": "mieszkania",
  "location": "warszawa",
  "startUrls": [],
  "postedWithinDays": "any",
  "maxResults": 100,
  "includeDetails": true
}
```

# Actor output Schema

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

Table of scraped property listings with key fields.

# 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 = {
    "transactionType": "sprzedaz",
    "propertyType": "mieszkania",
    "location": "warszawa",
    "startUrls": [],
    "postedWithinDays": "any",
    "maxResults": 100,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/morizon-pl-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 = {
    "transactionType": "sprzedaz",
    "propertyType": "mieszkania",
    "location": "warszawa",
    "startUrls": [],
    "postedWithinDays": "any",
    "maxResults": 100,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/morizon-pl-scraper").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 '{
  "transactionType": "sprzedaz",
  "propertyType": "mieszkania",
  "location": "warszawa",
  "startUrls": [],
  "postedWithinDays": "any",
  "maxResults": 100,
  "includeDetails": true
}' |
apify call solidcode/morizon-pl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Morizon.pl Property Scraper",
        "description": "[💰 $3.0 / 1K] Extract Polish real-estate listings from Morizon (morizon.pl) — sale and rent apartments, houses, plots, rooms, garages, commercial. Get price, area, rooms, location, GPS, building specs, condition, and agent contacts. Search by filters or paste URLs.",
        "version": "1.0",
        "x-build-id": "m2wsDaUn4WUYZyCSg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~morizon-pl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-morizon-pl-scraper",
                "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/solidcode~morizon-pl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-morizon-pl-scraper",
                "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/solidcode~morizon-pl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-morizon-pl-scraper",
                "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": {
                    "transactionType": {
                        "title": "For Sale or For Rent",
                        "enum": [
                            "sprzedaz",
                            "wynajem"
                        ],
                        "type": "string",
                        "description": "Collect properties for sale (sprzedaż) or for rent (wynajem). Ignored when Start URLs are provided.",
                        "default": "sprzedaz"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "mieszkania",
                            "domy",
                            "dzialki",
                            "pokoje",
                            "garaze",
                            "nieruchomosci-komercyjne"
                        ],
                        "type": "string",
                        "description": "Property category to search. Choose 'Any' to include all types. Ignored when Start URLs are provided.",
                        "default": "mieszkania"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search. Enter a city on its own (e.g. 'warszawa', 'krakow') to cover the whole city. To target a district, add it after a slash — for example 'krakow/stare-miasto' or 'warszawa/mokotow'. Leave empty to search all of Poland. Ignored when Start URLs are provided."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste morizon.pl URLs directly — either search-result pages (e.g. https://www.morizon.pl/mieszkania/warszawa/) or individual listing pages. When provided, these override the For Sale/Rent, Property Type, Location, and all filter settings above; any filters already in the URL (price, area, rooms, sort) are preserved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum Price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price, in Polish złoty (PLN). Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price, in Polish złoty (PLN). Leave empty for no maximum."
                    },
                    "areaMin": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties at or above this area, in square metres. Leave empty for no minimum."
                    },
                    "areaMax": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties at or below this area, in square metres. Leave empty for no maximum."
                    },
                    "roomsMin": {
                        "title": "Minimum Rooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at least this many rooms. Leave empty for no minimum."
                    },
                    "roomsMax": {
                        "title": "Maximum Rooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at most this many rooms. Leave empty for no maximum."
                    },
                    "postedWithinDays": {
                        "title": "Posted Within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only include listings first posted within this many days. Choose 'Any time' for no recency limit.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all searches and URLs combined. Set to 0 for as many as possible (up to a built-in safety cap). Results are collected in full pages, so the final page may overshoot this cap by a few listings. Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Listing Details",
                        "type": "boolean",
                        "description": "Open each listing's detail page to capture the full record — the whole photo gallery, map coordinates, building specs (type, material, year built, heating), condition, market and ownership type, seller/agent name and phone, and the full description. Slower but much richer. When off, only the fields shown on result pages are returned.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
