# Morizon Property Search Scraper (`stealth_mode/morizon-property-search-scraper`) Actor

Scrape comprehensive property listings from Morizon.pl, Poland's leading real estate portal. Extract apartments, houses, prices, locations, photos, floor plans, and contact details from search results. Ideal for real estate agencies, market analysts, property aggregators, and investment research.

- **URL**: https://apify.com/stealth\_mode/morizon-property-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Real estate
- **Stats:** 5 total users, 0 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 Search Scraper: Extract Polish Real Estate Listings Data

### Understanding Morizon.pl and Polish Real Estate Data

Morizon.pl is one of Poland's largest property portals, featuring hundreds of thousands of listings across apartments (mieszkania), houses (domy), commercial properties, and land. The platform aggregates offerings from developers, agencies, and private sellers, making it a comprehensive source for Polish real estate market intelligence.

The platform specializes in the Polish market with localized features: pricing in PLN, Polish location hierarchies (voivodeship/city/district), and local market conventions. For international investors entering Poland, property aggregators building databases, or real estate agencies monitoring competition, Morizon provides essential market data unavailable elsewhere.

Manual data collection across multiple searches, pages, and property types would require extensive clicking and copying. This scraper automates the entire process, transforming search result pages into structured datasets for analysis, integration, or competitive monitoring.

### What This Scraper Extracts and Target Users

The Morizon.pl Property Search Scraper processes search result pages—the listings displayed after applying filters for location, property type, price range, or other criteria. It captures multiple properties per page, efficiently building large datasets.

**Key extracted data includes:**

Property identifiers (ID, frontend ID, URL), pricing details (total price, price per m2 with formatted versions), physical characteristics (area, number of rooms, floor), location information, visual assets (photos, 3D views, videos, floor plans), promotional flags (highlighted, recommended), timestamps (added date), and contact information.

**Primary users:**

**Real Estate Agencies** monitor competitor listings, pricing strategies, and market inventory. **Property Aggregators** build comprehensive databases integrating Morizon with other sources. **Investment Analysts** track pricing trends, supply levels, and market dynamics across Polish cities. **Market Researchers** analyze location-based demand, price per m2 variations, and property type distributions. **Developers** benchmark their offerings against market competition and identify pricing opportunities.

### Input Configuration: Search URLs and Parameters

The scraper processes Morizon search result URLs—pages showing multiple property listings with applied filters.

**Example Input:**

```json
{
  "proxy": {
    "useApifyProxy": false
  },
  "max_items_per_url": 20,
  "ignore_url_failures": true,
  "urls": [
    "https://www.morizon.pl/mieszkania/najnowsze/?page=2"
  ]
}
````

#### Example Screenshot:

![](https://i.ibb.co/0vTFPKX/Screenshot-from-2026-01-02-16-41-13.png)

**Parameter breakdown:**

**proxy configuration:** Set `useApifyProxy: false` if not using proxies, or configure residential proxies for large-scale scraping to avoid detection. For occasional use, proxies may be unnecessary.

**max\_items\_per\_url:** Limits properties extracted per search page. Set to 20 for standard pages (Morizon typically shows 20-25 listings per page). Increase to 50-100 for comprehensive extraction if pages contain more results.

**ignore\_url\_failures:** When `true`, continues processing if individual URLs fail. Essential for bulk operations where some pages might be temporarily unavailable or have changed.

**urls array:** Contains search result page URLs. Include multiple searches for different locations, property types, or price ranges. Use pagination (`?page=1`, `?page=2`) for deep data collection.

**Building URLs:** Perform manual searches on Morizon with desired filters (location, price, rooms, area). Copy the resulting URL. For multi-page datasets, systematically increment the page parameter.

### Complete Output Structure and Field Definitions

**Added At:** Timestamp when listing was added to Morizon. **Use:** Track new listings, analyze posting patterns, identify fresh opportunities, measure market velocity.

**Advertisement Text:** Promotional text if property is featured/advertised. **Use:** Identify premium listings, analyze advertising strategies, filter sponsored vs. organic results.

**Area:** Property size in square meters (m2). **Use:** Primary filtering criterion, calculate price per m2, segment by size categories, analyze size-price correlations.

**Contact:** Contact information object (phone, email, agent name). **Use:** Lead generation, direct outreach to sellers/agents, building contact databases.

**Development:** Development/building project name if new construction. **Use:** Track developer projects, identify new construction hotspots, analyze developer portfolios.

**Description:** Full property description text. **Use:** Keyword extraction, feature analysis (parking, balcony, renovated), sentiment analysis, content for property portals.

**Floor Formatted:** Human-readable floor information (e.g., "3/5" means 3rd floor of 5). **Use:** Filter by floor preferences, analyze floor premiums in pricing, identify ground/top floor properties.

**Highlight Text:** Special highlighting message if featured. **Use:** Identify promoted listings, competitive intelligence on marketing spend.

**ID / ID On Frontend:** Unique identifiers assigned by Morizon. **Use:** Primary keys for databases, tracking properties over time, avoiding duplicates, linking to detail pages.

**Is Highlighted / Is Recommended:** Boolean flags for promotional status. **Use:** Filter premium listings, analyze correlation between promotion and pricing/time-on-market.

**Location:** Detailed location object with city, district, voivodeship, coordinates. **Use:** Geographic filtering, market segmentation, mapping visualizations, location-based pricing analysis.

**Number Of Rooms:** Room count. **Use:** Primary search criterion, market segmentation, identify studio vs. family apartments, analyze room-price relationships.

**Photos / Photos Number:** Array of photo URLs and photo count. **Use:** Visual assets for listings, quality indicator (more photos = professional listing), image analysis for features.

**Has 3D View / Has Video:** Boolean flags for rich media content. **Use:** Quality indicators, filter modern/professional listings, competitive analysis on presentation quality.

**Plans:** Floor plan images/URLs. **Use:** Layout visualization, property comparison, identifying desirable configurations.

**Price / Price Formatted:** Total property price in PLN (raw and formatted). **Use:** Primary filtering, price trend analysis, market statistics, investment evaluation.

**Price m2 / Price m2 Formatted:** Price per square meter (raw and formatted). **Use:** Standardized comparison across different-sized properties, market benchmarking, identifying overpriced/underpriced listings.

**Promotion Points:** Numerical score for promotional priority. **Use:** Ranking algorithm analysis, understanding listing visibility, competitive positioning.

**Title:** Property listing headline. **Use:** Primary display text, quick scanning, feature extraction (luxury, modern, renovated).

**URL:** Direct link to full property page on Morizon. **Use:** Access complete details, share with clients, verification of scraped data.

**Sample Output:**

```json
[
  {
  "added_at": "2026-01-02",
  "advertisement_text": "4 pokoje Daktylowa Stabłowice 2 tarasy balkon",
  "area": "86",
  "contact": {
    "company": {
      "address": [
        "Kleczkowska 30 / 2",
        "50-227 Wrocław"
      ],
      "faxes": [],
      "name": "EVESTA SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
      "id": 64553,
      "logo": {
        "alt": "EVESTA SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
        "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL2xvZ28vNjQ1NTMjdj0xNzY1ODM1MTM5",
        "name": "evesta-spolka-z-ograniczona-odpowiedzialnoscia"
      },
      "phones": [
        "531 103 298"
      ],
      "type": "AGENCY"
    },
    "person": {
      "faxes": [],
      "name": "Bartosz Świdziński",
      "phones": [
        "533 163 112"
      ],
      "photo": null,
      "type": "AGENT",
      "url": null
    }
  },
  "development": null,
  "description": "Na sprzedaż przestronne 4-pokojowe mieszkanie o powierzchni 86,96 m² , położone na piętrze nowoczesnego budynku przy ul. Daktylowej we Wrocławiu. Mieszkanie zostało zaprojektowane z myślą o komforcie i funkcjonalności, z dużą przestrzenią dzienną oraz dwoma tarasami . Wysokość pomieszczeń...",
  "floor_formatted": "piętro 1/1",
  "highlight_text": null,
  "id": 1541741928,
  "id_on_frontend": "mzn2046792433",
  "is_highlighted": false,
  "is_recommended": false,
  "location": {
    "location": [
      "Wrocław",
      "Stabłowice"
    ],
    "street": "Daktylowa"
  },
  "number_of_rooms": "4 pokoje",
  "photos": [
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 1",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzYvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU18xLmpwZyN2PTFfMzkxMTE3MDk5NA==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 2",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzEvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU18yLmpwZyN2PTFfMzkxMTE3MDk5NQ==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 3",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhL2QvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU18zLmpwZyN2PTFfMzkxMTE3MDk5Ng==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 4",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhL2YvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU180LmpwZyN2PTFfMzkxMTE3MDk5Nw==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 5",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzkvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU181LmpwZyN2PTFfMzkxMTE3MDk5OA==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 6",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzYvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU182LmpwZyN2PTFfMzkxMTE3MDk5OQ==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 7",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzUvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU183LmpwZyN2PTFfMzkxMTE3MTAwMA==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 8",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzUvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU184LmpwZyN2PTFfMzkxMTE3MTAwMQ==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    },
    {
      "alt": "Mieszkanie na sprzedaż 87m2 Wrocław Fabryczna Stabłowice Daktylowa - zdjęcie 9",
      "id": "aHR0cDovL21lZGlhLmRvbXkucGwvaW1nL3pkamVjaWEvZXZlc3RhLzcvZXZlc3RhX21zXzI5NSUyNTJGMTgwNjglMjUyRk9NU185LmpwZyN2PTFfMzkxMTE3MTAwMg==",
      "name": "mieszkanie-na-sprzedaz-wroclaw-fabryczna-86-m"
    }
  ],
  "photos_number": 9,
  "promotion_points": 0,
  "has3d_view": false,
  "has_video": false,
  "plans": [],
  "price": {
    "amount": "1321879.00",
    "currency": "PLN"
  },
  "price_formatted": "1 321 879 zł",
  "price_m2": {
    "amount": "15201.00",
    "currency": "PLN"
  },
  "price_m2_formatted": "15 201 zł/m²",
  "title": "mieszkanie na sprzedaż",
  "url": "/oferta/sprzedaz-mieszkanie-wroclaw-fabryczna-daktylowa-86m2-mzn2046792433",
  "from_url": "https://www.morizon.pl/mieszkania/najnowsze/?page=2"
}
]
```

### Step-by-Step Usage Guide

**1. Define Target Properties:** Determine what you need—apartments in Warsaw, houses in Krakow, commercial properties nationwide. Consider price ranges, sizes, and specific locations.

**2. Build Search URLs:** Perform test searches on Morizon.pl with desired filters. Copy resulting URLs. For comprehensive data, create multiple URLs covering different searches and page numbers.

**3. Configure Input:** Set up JSON with your URL list. Adjust `max_items_per_url` based on needs. Enable `ignore_url_failures` for robustness when scraping many pages.

**4. Execute Scraper:** Launch via Apify console. Monitor progress. Processing 10 search pages with 20 properties each typically completes in 3-5 minutes.

**5. Review Results:** Check dataset preview for completeness. Verify prices, locations, and contact details appear correct. Identify any data quality issues.

**6. Export Data:** Export as JSON for databases, CSV for Excel analysis, or integrate directly via API. Filter out unwanted promotional listings if needed.

**7. Handle Pagination:** For large datasets, include multiple page URLs (`?page=1` through `?page=20`) or set high `max_items_per_url` for automatic pagination.

**Troubleshooting:** Verify URLs are search result pages, not individual property pages. Check that filters in URLs remain valid (Morizon may update parameter names). Review activity logs for specific error messages.

### Strategic Applications in Polish Real Estate

**Market Price Analysis:** Track price per m2 across locations, property types, and time periods. Identify undervalued areas, emerging neighborhoods, and pricing anomalies. Calculate average prices by district and room count.

**Competitive Intelligence:** Monitor competitor agencies' listings—inventory levels, pricing strategies, promoted properties. Identify aggressive pricing, market share by location, and time-on-market indicators.

**Investment Opportunity Detection:** Set alerts for properties below market average price per m2. Identify distressed sales, motivated sellers (frequent price updates), and underpriced assets.

**Supply-Demand Dynamics:** Track listing volumes by location and property type. Declining inventory in specific districts signals high demand. Analyze room count distributions to understand market preferences.

**Developer Project Tracking:** Monitor new developments via "development" field. Track construction progress, pricing evolution, and absorption rates. Identify active developers and their geographic focus.

**Location Premium Analysis:** Compare prices across districts within cities. Quantify premiums for central locations, proximity to metro, or specific neighborhoods. Inform investment targeting and pricing strategies.

**Marketing Effectiveness:** Analyze correlation between promotional flags (highlighted, recommended) and pricing. Determine if premium listings sell faster or at higher prices, informing advertising budget allocation.

**Contact Database Building:** Extract agent contacts for partnership development, lead generation, or market research interviews. Segment contacts by agency, location, and property specialization.

### Maximizing Data Value: Best Practices

**Regular Scraping Schedules:** The Polish property market updates continuously. Weekly scraping captures new listings and tracks market dynamics. Daily scraping during active seasons (spring/fall) provides real-time intelligence.

**Geographic Segmentation:** Create separate searches for major cities (Warsaw, Krakow, Wrocław, Gdańsk) and smaller markets. This produces cleaner datasets and enables comparative analysis.

**Property Type Separation:** Scrape apartments, houses, and commercial properties separately. Different property types have distinct market dynamics requiring separate analysis.

**Historical Tracking:** Store scraped data with timestamps. Track individual properties over time—price changes signal motivated sellers, removed listings indicate sales, added listings show new supply.

**Enrich with External Data:** Combine Morizon data with city development plans, transport infrastructure projects, school ratings, and crime statistics for comprehensive location analysis.

**Price Outlier Detection:** Flag listings with price per m2 significantly above/below local averages. May indicate data errors, unique property features, or mispriced opportunities.

**Photo Quality Indicators:** Properties with high photo counts and 3D views typically represent professional sellers with higher closing rates. Use as quality filter for serious listings.

**Contact Deduplication:** Same agents often list multiple properties. Deduplicate contacts by phone/email to avoid duplicate outreach when building agency databases.

### Data Governance and Compliance

**Update Frequency:** Balance data freshness needs against scraping volume. Weekly updates suit market analysis; daily for active deal sourcing.

**Privacy Compliance:** Contact information may be personal data under GDPR. Implement appropriate storage security, access controls, and use only for legitimate business purposes.

**Data Validation:** Check for missing critical fields (price, area, location). Flag unusual values (price per m2 below 3000 or above 30000 PLN/m2 may indicate errors).

**Storage Strategy:** Organize data by scrape date and search parameters. Maintain separate active vs. archived listings databases. Track when properties first appeared and when removed (indicating sale).

**Rate Limiting:** Space out large scraping runs to avoid overwhelming Morizon's servers. Sustainable practices ensure continued data access.

**Attribution:** Store source URLs and scrape timestamps for verification, troubleshooting, and understanding data freshness when making decisions.

### Conclusion

The Morizon.pl Property Search Scraper transforms Poland's leading real estate portal into actionable market intelligence. Whether building property aggregation platforms, conducting investment analysis, or monitoring competitive landscapes, this tool delivers comprehensive data for informed decisions in Poland's dynamic property market. Start extracting Polish real estate insights today.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://www.morizon.pl/mieszkania/najnowsze/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.morizon.pl/mieszkania/najnowsze/?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/morizon-property-search-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 = {
    "urls": ["https://www.morizon.pl/mieszkania/najnowsze/?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/morizon-property-search-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 '{
  "urls": [
    "https://www.morizon.pl/mieszkania/najnowsze/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call stealth_mode/morizon-property-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Morizon Property Search Scraper",
        "description": "Scrape comprehensive property listings from Morizon.pl, Poland's leading real estate portal. Extract apartments, houses, prices, locations, photos, floor plans, and contact details from search results. Ideal for real estate agencies, market analysts, property aggregators, and investment research.",
        "version": "0.0",
        "x-build-id": "4ym3Zbmv3wK4Wuqhy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~morizon-property-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-morizon-property-search-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/stealth_mode~morizon-property-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-morizon-property-search-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/stealth_mode~morizon-property-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-morizon-property-search-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": {
                    "urls": {
                        "title": "URLs of the property list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```