# Morizon Property Extractor (`kawsar/morizon-property-extractor`) Actor

Pulls apartment and house listings off Morizon, price, area, rooms, location and all, so you can track the Polish property market without copying data by hand.

- **URL**: https://apify.com/kawsar/morizon-property-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (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 $2.99 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Property Extractor

Extract apartment and house listings from [Morizon.pl](https://www.morizon.pl), one of Poland's largest real estate portals. Point this actor at any Morizon search result page, newest listings, a filtered city search, a price range, whatever you're tracking, and it returns structured data for every property on that search: price, area, room count, floor, location, photos, and more. Pagination is handled automatically, so a single run can cover hundreds of listings without manual clicking.

### Why use this actor

Morizon lists thousands of new properties every day, but there's no public API for pulling that data into a spreadsheet, a valuation model, or a monitoring dashboard. This actor closes that gap: give it a search URL, get back clean structured rows, ready for analysis.

Typical users:

- **Real estate agencies** tracking competitor listings and pricing in specific neighborhoods
- **Market analysts and investors** building historical pricing datasets for the Polish housing market
- **Proptech and valuation tools** that need fresh comparable-sale data as an input
- **Researchers and journalists** studying regional housing trends over time

### What data it extracts

Each row in the output dataset represents one property listing:

| Field | Description |
|---|---|
| `listingId` | Morizon's internal listing identifier, parsed from the URL |
| `listingUrl` | Full URL to the listing page |
| `listingTitle` | Listing headline |
| `location` | Street, district, city, and region |
| `price` | Asking price (numeric) |
| `priceCurrency` | Currency code, `PLN` |
| `pricePerSquareMeter` | Price per square meter |
| `areaSquareMeters` | Living area in square meters |
| `numberOfRooms` | Number of rooms |
| `floorInfo` | Floor, formatted as it appears on the listing (e.g. `piętro 5/6`) |
| `listingSummary` | Short excerpt from the listing description |
| `addedAt` | Date the listing was added or last updated |
| `imageUrls` | Array of listing photo URLs |
| `scrapedAt` | Timestamp the row was collected, in UTC |

### How to use it

1. Open the actor and paste one or more Morizon search result URLs into **Search result URLs**. Examples:
   - `https://www.morizon.pl/mieszkania/najnowsze/` (newest apartment listings nationwide)
   - `https://www.morizon.pl/mieszkania/warszawa/` (apartments in a specific city)
   - Any filtered search URL copied straight from your browser's address bar, including price ranges, room counts, or districts
2. Set **Max items** to the total number of listings you want across all start URLs (default 100, maximum 1000).
3. Optionally adjust **Request timeout**.
4. Run the actor. It fetches each start URL, follows pagination automatically, and stops once it hits your item limit or runs out of results.
5. Export the dataset as JSON, CSV, Excel, or XML, or pull it through the Apify API.

#### Example input

```json
{
  "startUrls": [
    "https://www.morizon.pl/mieszkania/najnowsze/"
  ],
  "maxItems": 200
}
```

#### Example output

```json
{
  "listingId": "mzn2047083029",
  "listingUrl": "https://www.morizon.pl/oferta/sprzedaz-mieszkanie-warszawa-mokotow-swietego-bonifacego-101m2-mzn2047083029",
  "listingTitle": "Mokotów, czteropokojowe mieszkanie, garaż.",
  "location": "Świętego Bonifacego, Stegny, Mokotów, Warszawa, mazowieckie",
  "price": 2230000,
  "priceCurrency": "PLN",
  "pricePerSquareMeter": 21970,
  "areaSquareMeters": 101,
  "numberOfRooms": 4,
  "floorInfo": "piętro 5/6",
  "listingSummary": "Komfortowe, czteropokojowe mieszkanie o powierzchni 101,5 m2...",
  "addedAt": "2026.03.31",
  "imageUrls": ["https://img1.staticmorizon.com.pl/..."],
  "scrapedAt": "2026-08-16T10:00:00.000000+00:00"
}
```

### Use cases

- **Market monitoring** — track new listings in a city or district as they go live, priced above or below the local average.
- **Pricing datasets** — collect price-per-square-meter data across neighborhoods to spot trends over time.
- **Competitor tracking** — watch what agencies list, at what price, and how long listings stay active.
- **Feeding downstream tools** — pipe structured listings into a valuation model, CRM, or market report.

### Frequently asked questions

**Can I scrape more than one search page at once?**
Yes. Add multiple start URLs and the actor processes each one, following pagination for every URL until it reaches your item limit.

**Does it work for both sale and rental listings?**
Yes. Any Morizon search result page URL works, whether it's for sale, rent, apartments, or houses.

**Can I filter by city, price, or number of rooms?**
Yes, filter directly on Morizon.pl and copy the resulting search URL into **Search result URLs**. Any filters applied on the site carry over to the scrape.

**How often should I run this?**
Morizon updates listings continuously. Running the actor daily, or a few times a week for slower-moving markets, keeps a pricing dataset current without redundant runs.

**What happens if a listing is missing a field?**
Not every listing includes every field, for example some omit floor information. Missing fields are returned as `null` rather than causing the run to fail.

### Support

Found an issue or have a feature request? Reach out through the Apify platform's actor issue tracker.

# Actor input Schema

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

Morizon.pl search result page URLs to extract listings from, for example a category or 'najnowsze' (newest) listing page. Pagination is followed automatically.

## `maxItems` (type: `integer`):

Maximum number of property listings to return in total.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.morizon.pl/mieszkania/najnowsze/"
  ],
  "maxItems": 100,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `properties` (type: `string`):

All extracted Morizon.pl property listings, one row per property.

# 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 = {
    "startUrls": [
        "https://www.morizon.pl/mieszkania/najnowsze/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/morizon-property-extractor").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 = { "startUrls": ["https://www.morizon.pl/mieszkania/najnowsze/"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/morizon-property-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.morizon.pl/mieszkania/najnowsze/"
  ]
}' |
apify call kawsar/morizon-property-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/morizon-property-extractor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/TC0cuLg63cw8R4Jcl/builds/3VIChBKB9mo2scUne/openapi.json