# Otodom Scraper – Polish Real Estate Listings (Sale & Rent) (`haketa/otodom-scraper`) Actor

Otodom scraper & API for Polish real estate: search apartments and houses for sale and rent and export address, price, rooms, area, floor, type, private-vs-agency, photos and coordinates. Poland property market data and real-estate lead generation — fast, no login.

- **URL**: https://apify.com/haketa/otodom-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Otodom Scraper – Polish Real Estate Listings (Sale & Rent)

[![Apify Actor](https://img.shields.io/badge/Apify%20Actor-Ready-blue?logo=apify)](https://apify.com/haketa/otodom-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/otodom-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/otodom-scraper)
[![Country](https://img.shields.io/badge/Country-Poland%20%F0%9F%87%B5%F0%9F%87%B1-red)](#)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Listings-success)](#)

**Scrape Otodom.pl — Poland's #1 real estate marketplace — into clean, structured datasets.** This high-throughput **Otodom scraper** extracts **sale (sprzedaż)** and **rental (wynajem)** property listings from [Otodom.pl](https://www.otodom.pl) with prices in **PLN**, **price per m²**, rent fee, rooms, living area, floor number, full municipal location breakdown, amenity features, and a dedicated **private-owner (od właściciela / FSBO) vs. agency** classification with contact names for real estate lead generation.

Whether analyzing investment yields across Warsaw, sourcing direct seller mandates, or bulk-exporting 1,000+ listings across Poland, everything exports cleanly into **JSON, CSV, Excel, or programmatic API**.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | Otodom.pl (`otodom.pl/pl/wyniki/...`) |
| **Transaction Types** | Sale (`sprzedaz`) and Long-term Rental (`wynajem`) |
| **Property Types** | Apartments (`mieszkanie`), Houses (`dom`), Plots (`dzialka`), Commercial (`lokal`), Warehouses, Garages, Rooms |
| **Geographic Coverage** | All Poland (`cala-polska`) or any specific voivodeship, county, or city (Warsaw, Kraków, Wrocław, etc.) |
| **Lead Generation Features** | `isPrivateOwner` flag, `agentName` (owner/broker contact name), `agencyName` |
| **Financial Metrics** | Total Price (PLN), Price per Square Meter (PLN/m²), Monthly Maintenance Rent Fee (`rentFee`) |
| **Pagination & Depth** | Unlocked deep pagination supporting **1,000+ listings** per search |
| **Architecture** | Direct Next.js `__NEXT_DATA__` extraction (Cheerio, no browser overhead) |
| **Proxy Requirement** | Polish (PL) residential proxy enabled by default for unblocked continuity |
| **Export Formats** | Dataset JSON, flat CSV, spreadsheet Excel, XML, HTML, Webhook integrations |

***

### 🔎 Why scrape Otodom.pl?

[Otodom](https://www.otodom.pl) is the undisputed market leader in Polish real estate, hosting hundreds of thousands of active listings for sale and rent. For PropTech founders, private equity investors, real estate brokers, and market analysts, Otodom provides the single richest live index of asking prices, rental yields, and housing inventory across Poland.

However, scraping Otodom programmatically presents technical roadblocks:

1. **Dynamic Next.js architecture**: Infinite scroll and client-side hydration require parsing embedded JSON payloads rather than traditional static HTML tags.
2. **Strict regional path routing**: Submitting simple query strings like `"warszawa"` directly often returns empty shell pages; Otodom strictly requires canonical nested administrative paths (e.g. `mazowieckie/warszawa/warszawa`).
3. **Broken URL owner filters**: URL parameters for owner type frequently fail to filter server-side on Otodom's backend, requiring robust client-side post-filtering.
4. **Geo-blocking**: Non-Polish IP addresses frequently encounter blocking or localized content shifts.

This **Otodom data extractor** solves every one of these problems. It includes built-in administrative path mapping for all 20+ major Polish metropolitan hubs, automated client-side owner filtering, Next.js payload parsing, and native PL residential proxy support.

***

### ⚖️ Feature comparison: Why choose this Actor?

| Feature | Browser-Based Scrapers | Manual Browsing | This Apify Actor |
|---|---|---|---|
| **Speed** | 1–3 listings/second | Extremely slow | **36 listings per page request (~25s for 150+ listings)** |
| **Resource Cost** | Heavy RAM (2–4 GB) | High labor cost | **Low RAM (512 MB HTTP CheerioCrawler)** |
| **FSBO Detection** | Manual inspection | Tedious filtering | **Instant `isPrivateOwner` & contact name parsing** |
| **Location Routing** | Frequent empty shell errors | Manual navigation | **Automated 20+ Polish metro path resolver** |
| **Deep Pagination** | Fragile DOM clicking | Page-by-page | **Deep page iteration up to 1,000+ items** |
| **Export Formats** | Custom code needed | Copy-pasting | **One-click CSV, Excel, JSON, API** |

***

### ✨ Core capabilities

- 🏢 **Sale & rent in one actor**: Toggle seamlessly between property purchase (`sprzedaz`) and residential rental (`wynajem`) listings.
- 🎯 **FSBO private owner lead generation**: Filter for `ownerType: PRIVATE` to capture direct-owner listings with seller contact names, bypassing agency fees.
- 📐 **Granular property metrics**: Captures total price (PLN), price/m², monthly administrative rent fees (`czynsz`), exact living area, room count, and floor level.
- 🗺️ **Comprehensive administrative location**: Normalizes province (voivodeship), county, city, district/neighborhood, and street names.
- 📍 **Coordinates & geo mapping**: Extracts latitude and longitude coordinates when provided in listing metadata.
- 🏙️ **Nationwide coverage**: Pre-mapped shortcuts for Warsaw, Kraków, Wrocław, Poznań, Gdańsk, Szczecin, Katowice, Łódź, and all 16 Polish voivodeships.
- 🧹 **Automatic deduplication**: Employs unique Otodom listing IDs and canonical offer URLs to ensure 0 duplicate records.
- 🛡️ **Anti-block resilience**: Pre-configured with Polish (PL) residential proxy rotation and smart retry backoff.

***

### 🎯 Use cases & industry applications

#### 1. Real estate investment & yield analysis

- **Rental yield mapping**: Compare asking purchase prices against rental rates in the same Warsaw or Kraków districts to calculate gross rental yields.
- **Historical price trends**: Track price per square meter (PLN/m²) fluctuations across primary and secondary Polish housing markets.

#### 2. Brokerage & FSBO lead generation

- **Source direct-owner mandates**: Real estate agents can filter for private sellers (`od właściciela`) and contact them with the parsed `agentName` to pitch representation.
- **Competitor agency monitoring**: Track which rival agencies are listing properties in your target neighborhood and benchmark commission pricing.

#### 3. PropTech & automated valuation models (AVM)

- **Model training & calibration**: Ingest thousands of fresh market listings to train property valuation and appraisal algorithms.
- **Comparative Market Analysis (CMA)**: Generate automated valuation reports for home buyers and mortgage lenders.

#### 4. Relocation & expat housing platforms

- **Curated rental feeds**: Surface furnished, pet-friendly, or multi-room apartments for corporate relocations and international students.

***

### 📥 Input parameters

The actor is ready to run immediately with zero configuration (defaulting to sale listings in Warsaw or nationwide), while supporting comprehensive parametric filters.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `dealType` | `select` | `"sprzedaz"` | Transaction type: `"sprzedaz"` (For sale) or `"wynajem"` (For rent). |
| `propertyType` | `select` | `"mieszkanie"` | Property type: `mieszkanie` (Apartment), `dom` (House), `dzialka` (Plot), `lokal` (Commercial), `haleimagazyny` (Warehouse), `garaz` (Garage), or `pokoj` (Room). |
| `region` | `select` | `"cala-polska"` | Target metro or region (e.g., `warszawa`, `krakow`, `wroclaw`, `poznan`, `gdansk`, or `cala-polska`). |
| `regionCustom` | `string` | `null` | Optional custom administrative path for smaller municipalities (e.g. `malopolskie/wadowice/wadowice`). |
| `ownerType` | `select` | `"ALL"` | Seller filter: `"ALL"`, `"PRIVATE"` (direct owners only / FSBO), or `"AGENCY"`. |
| `priceMin` | `integer` | `null` | Minimum price in Polish złoty (PLN). |
| `priceMax` | `integer` | `null` | Maximum price in Polish złoty (PLN). |
| `areaMin` | `integer` | `null` | Minimum living area in square meters (m²). |
| `areaMax` | `integer` | `null` | Maximum living area in square meters (m²). |
| `roomsMin` | `integer` | `null` | Minimum room count. |
| `roomsMax` | `integer` | `null` | Maximum room count. |
| `maxItems` | `integer` | `0` | Maximum listings to collect (`0` = unlimited, iterates all pages). |
| `startUrls` | `array` | `[]` | Optional direct Otodom search URLs (overrides standard dropdown filters). |
| `proxyConfiguration` | `object` | `RESIDENTIAL (PL)` | Recommended Polish residential proxy for maximum reliability. |

#### Sample JSON configuration

```json
{
  "dealType": "sprzedaz",
  "propertyType": "mieszkanie",
  "region": "warszawa",
  "ownerType": "PRIVATE",
  "priceMin": 400000,
  "priceMax": 1200000,
  "areaMin": 40,
  "areaMax": 85,
  "roomsMin": 2,
  "roomsMax": 4,
  "maxItems": 150,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "PL"
  }
}
```

***

### 📊 Output data fields

Every record pushed to the Apify dataset represents a verified real estate listing. Numeric metrics are typed for instant mathematical calculations.

| Field | Coverage | Type | Description |
|---|---|---|---|
| `dealType` | 🟢 High (100%) | String | Transaction type (`"sprzedaz"` or `"wynajem"`). |
| `propertyType` | 🟢 High (100%) | String | Property category (`"mieszkanie"`, `"dom"`, etc.). |
| `title` | 🟢 High (100%) | String | Full advertisement headline title. |
| `price` | 🟢 High (98%) | Number | Total asking price in Polish złoty (PLN). |
| `currency` | 🟢 High (100%) | String | Currency identifier (`"PLN"`). |
| `pricePerSquareMeter` | 🟢 High (95%) | Number | Calculated or listed price per square meter (PLN/m²). |
| `rentFee` | 🟡 Conditional (45%) | Number | Monthly administrative rent fee (`czynsz`) in PLN. |
| `area` | 🟢 High (99%) | Number | Total living area in square meters (m²). |
| `rooms` | 🟢 High (95%) | Number | Total count of bedrooms and living rooms. |
| `floor` | 🟡 Conditional (80%) | String | Floor number (e.g., `"2"`, `"parter"`). |
| `city` | 🟢 High (100%) | String | City or municipal town name (e.g., `"Warszawa"`). |
| `district` | 🟢 High (90%) | String | City district or neighborhood (e.g., `"Mokotów"`, `"Śródmieście"`). |
| `province` | 🟢 High (100%) | String | Polish voivodeship (e.g., `"mazowieckie"`). |
| `street` | 🟡 Conditional (65%) | String | Street address when disclosed by seller. |
| `latitude` | 🟡 Conditional (75%) | Number | Geographical coordinate latitude. |
| `longitude` | 🟡 Conditional (75%) | Number | Geographical coordinate longitude. |
| `isPrivateOwner` | 🟢 High (100%) | Boolean | True if listed directly by owner (FSBO), false if agency. |
| `agencyName` | 🟡 Conditional (65%) | String | Real estate agency or developer firm name. |
| `agentName` | 🟢 High (85%) | String | Name of the owner or listing broker contact. |
| `isPromoted` | 🟢 High (100%) | Boolean | Whether the listing is currently boosted/featured. |
| `dateCreated` | 🟢 High (95%) | String | ISO timestamp when the listing was created or refreshed. |
| `thumbnail` | 🟢 High (98%) | String | Direct image CDN URL of primary photo. |
| `features` | 🟢 High (90%) | Array | List of property tags (e.g., `["balkon", "winda", "garaż"]`). |
| `url` | 🟢 High (100%) | String | Direct canonical URL to the listing on Otodom.pl. |
| `scrapedAt` | 🟢 High (100%) | String | ISO 8601 UTC timestamp of data extraction. |

***

### 📋 Example JSON output

```json
{
  "id": "64821904",
  "url": "https://www.otodom.pl/pl/oferta/nowoczesne-3-pokojowe-mieszkanie-mokotow-ID4rxyz",
  "dealType": "sprzedaz",
  "propertyType": "mieszkanie",
  "title": "Nowoczesne 3-pokojowe mieszkanie z balkonem | Mokotów",
  "price": 895000,
  "currency": "PLN",
  "pricePerSquareMeter": 14916,
  "rentFee": 750,
  "area": 60.0,
  "rooms": 3,
  "floor": "3",
  "floorsTotal": "6",
  "city": "Warszawa",
  "district": "Mokotów",
  "province": "mazowieckie",
  "street": "ul. Cybernetyki",
  "latitude": 52.1812,
  "longitude": 20.9945,
  "isPrivateOwner": true,
  "agencyName": null,
  "agentName": "Krzysztof Kowalski",
  "isPromoted": false,
  "dateCreated": "2026-11-08T10:15:00.000Z",
  "thumbnail": "https://images.otodom.pl/photos/medium/...",
  "features": ["balkon", "winda", "miejsce parkingowe", "klimatyzacja"],
  "scrapedAt": "2026-11-10T14:42:01.892Z"
}
```

***

### 💻 Programmatic usage examples

Integrate live Polish real estate data into your workflows using Apify's client SDKs:

#### Python integration

```python
from apify_client import ApifyClient

## Initialize the ApifyClient with your API token
client = ApifyClient("YOUR_APIFY_TOKEN")

## Search for private apartments for sale in Kraków
run_input = {
    "dealType": "sprzedaz",
    "propertyType": "mieszkanie",
    "region": "krakow",
    "ownerType": "PRIVATE",
    "priceMax": 1000000,
    "maxItems": 100
}

## Execute the actor
run = client.actor("haketa/otodom-scraper").call(run_input=run_input)

## Stream listings
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['district']}] {item['price']} PLN ({item['pricePerSquareMeter']} PLN/m²) - {item['agentName']}")
```

#### Node.js integration

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const input = {
    dealType: 'wynajem',
    propertyType: 'mieszkanie',
    region: 'warszawa',
    maxItems: 50,
};

const run = await client.actor('haketa/otodom-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Extracted ${items.length} Warsaw rental listings:`);
items.forEach(item => {
    console.log(`- ${item.title}: ${item.price} PLN/mo (Rent fee: ${item.rentFee} PLN)`);
});
```

***

### 🇵🇱 Polish administrative regions & cities reference

Otodom categorizes properties by Polish administrative hierarchy. You can target any of the 16 voivodeships or specific urban centers:

| Voivodeship (Województwo) | Major Cities & Otodom Slugs | Economic Profile |
|---|---|---|
| **Mazowieckie** | `warszawa` (Warsaw), `radom`, `plock` | Capital region, highest PLN/m², financial center |
| **Małopolskie** | `krakow` (Cracow), `tarnow`, `nowy-sacz` | Tech hub, tourism capital, high rental yields |
| **Dolnośląskie** | `wroclaw` (Breslau), `walbrzych`, `legnica` | Dynamic manufacturing, IT sector, rapid growth |
| **Wielkopolskie** | `poznan`, `kalisz`, `konin` | Strong commercial base, university market |
| **Pomorskie** | `gdansk`, `gdynia`, `sopot` (Tricity) | Baltic port cities, premium vacation & rental market |
| **Śląskie** | `katowice`, `czestochowa`, `gliwice`, `sosnowiec` | Silesian metropolitan area, highly affordable |
| **Łódzkie** | `lodz`, `piotrkow-trybunalski` | Central logistics hub, reviving post-industrial market |
| **Zachodniopomorskie**| `szczecin`, `koszalin`, `kolobrzeg` | Coastal gateway to Germany and Scandinavia |
| **Kujawsko-Pomorskie**| `bydgoszcz`, `torun` | Twin river cities with steady residential demand |
| **Lubelskie** | `lublin`, `zamosc`, `chelm` | Major university center in eastern Poland |
| **Podkarpackie** | `rzeszow`, `przemysl`, `mielec` | Aviation Valley, growing tech corridor |
| **Świętokrzyskie** | `kielce`, `ostrowiec-swietokrzyski` | Central transit crossroads |
| **Warmińsko-Mazurskie**| `olsztyn`, `elblag` | Masurian Lakes district, holiday properties |
| **Podlaskie** | `bialystok`, `suwalki` | Northeastern regional commerce hub |
| **Lubuskie** | `zielona-gora`, `gorzow-wielkopolski` | Western border trade corridor |
| **Opolskie** | `opole`, `kedzierzyn-kozle` | Industrial and transit center |

***

### 🧮 Calculating gross rental yield with extracted data

Using the exported fields from this actor, you can instantly compute expected gross rental yields across Polish micro-markets in Excel or Python:

$$\text{Gross Rental Yield (%)} = \left( \frac{\text{Monthly Rent (PLN)} \times 12}{\text{Purchase Price (PLN)}} \right) \times 100$$

#### Example Python calculation

```python
## Assuming matching comparable 2-room apartments in Warsaw Mokotów
avg_purchase_price = 780000  # PLN
avg_monthly_rent = 3800      # PLN

annual_rent = avg_monthly_rent * 12
gross_yield = (annual_rent / avg_purchase_price) * 100
print(f"Estimated Gross Rental Yield: {gross_yield:.2f}%")
## Result: Estimated Gross Rental Yield: 5.85%
```

***

### 🚀 How to use this actor

1. **Select transaction & property type**: Choose whether you are analyzing properties for sale (`sprzedaz`) or rent (`wynajem`), and select the target structure (apartments, houses, etc.).
2. **Select geographic territory**: Choose a major metropolitan city from the dropdown (e.g., Warsaw, Kraków, Wrocław) or enter a custom county path.
3. **Filter by listing source**: Set **Listed by** to `"Private owners only"` to isolate FSBO direct leads or leave as `"All"`.
4. **Define budget & dimensions**: Set optional constraints on min/max price (PLN), living area (m²), and room counts.
5. **Run the scraper**: Click **Start**. The actor logs real-time pagination progress, showing listings captured per page.
6. **Download data**: Export your records as CSV, Excel, or JSON, or query the Apify dataset directly via API.

***

### 💡 Best practices & optimization tips

- **Narrow by region for faster runs**: While `cala-polska` allows scraping nationwide inventory, picking specific metropolitan areas like `warszawa` or `krakow` allows much faster data collection.
- **FSBO Lead Generation**: When collecting seller leads, filter by `ownerType: PRIVATE`. The resulting dataset will contain direct owner contact names in the `agentName` field.
- **Always use Polish residential proxies**: Otodom monitors traffic origin closely. Keeping Apify's default Polish residential proxy (`useApifyProxy: true`, `apifyProxyCountry: "PL"`) ensures smooth, unblocked pagination.
- **Automate weekly market snapshots**: Set up a recurring Apify cron schedule to run every Monday to track weekly inventory influx and price-per-square-meter changes.

***

### ❓ Frequently Asked Questions (FAQ)

##### Do I need an Otodom account or login credentials?

No. The scraper collects publicly available listing data from Otodom without requiring any account or login authentication.

##### How many listings can I scrape in a single run?

There is no hard limit. The scraper handles single-page spot checks as well as deep multi-page batches of 1,000+ listings across Poland. Use `maxItems` to cap your extraction.

##### Can I paste custom search URLs from otodom.pl?

Yes. If you configure complex filters directly on otodom.pl (such as specific micro-neighborhoods or year-of-construction filters), copy the URL and paste it into the **Start URLs** input.

##### Why is `rentFee` (`czynsz`) missing on some listings?

The administrative rent fee is primarily relevant for apartments in multi-family buildings. For single-family houses or commercial plots, this field is naturally null.

##### How fresh is the extracted property data?

Every run queries Otodom's live search endpoints in real time, sorted by newest listings first (`LATEST`), ensuring immediate access to freshly posted properties.

***

### 🔗 Related real estate scrapers

- [Boliga Scraper](https://apify.com/haketa/boliga-scraper) — Danish property market prices, historical sales, and registry data.
- [Hemnet Scraper](https://apify.com/haketa/hemnet-scraper) — Swedish real estate listings and sold property records.
- [Realtor.ca Scraper](https://apify.com/haketa/realtor-ca-scraper) — Canadian MLS property listings nationwide.
- [ImmobilienScout24 Scraper](https://apify.com/haketa/immobilienscout24-scraper) — Germany's largest property portal.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Unlocked 1,000+ deep pagination**: Removed restrictive per-region caps, enabling extensive multi-page crawling across all 16 Polish voivodeships.
- **Enhanced district extraction**: Upgraded reverse-geocoding parsing to accurately separate administrative districts and sub-neighborhoods.
- **Accelerated prefill execution**: Streamlined request header negotiation to finish standard 100-item prefill runs in under 30 seconds.
- **Strict schema validation**: Updated schema specifications to 100% Apify CLI 2026 standards with full dataset overview view support.

#### Version 1.1 (2026-06)

- Added client-side post-filtering for `ownerType` (FSBO vs. agency).
- Implemented automated metropolitan path resolution for 20+ major Polish cities.
- Added support for administrative rent fee (`czynsz`) extraction.

#### Version 1.0 (2026-06)

- Initial release featuring Next.js `__NEXT_DATA__` parsing for sale and rental listings.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/otodom-scraper/changelog.md

# Actor input Schema

## `dealType` (type: `string`):

Scrape properties FOR SALE (sprzedaż) or FOR RENT (wynajem).

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

Type of property to scrape.

## `region` (type: `string`):

Pick all of Poland or one of the major cities. For a smaller town or a custom area, leave this on "All Poland" and use the Custom region field below. Ignored when Start URLs are provided.

## `regionCustom` (type: `string`):

Optional. For a town not in the list above, enter its Otodom area path, e.g. "malopolskie/wadowice/wadowice". When filled, this overrides the Region / city dropdown.

## `ownerType` (type: `string`):

Filter by who posted the listing. "Private only" is great for owner/FSBO lead generation.

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

Minimum price in Polish złoty.

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

Maximum price in Polish złoty.

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

Minimum living area in square meters.

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

Maximum living area in square meters.

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

Minimum number of rooms.

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

Maximum number of rooms.

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

Optional. Paste ready-made Otodom search result URLs (https://www.otodom.pl/pl/wyniki/...). When provided, these take priority and the filters above are ignored. Pagination is handled automatically.

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

Stop after collecting this many listings (0 = no limit).

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

Recommended. A Polish (PL) residential proxy gives the most reliable results on Otodom.

## Actor input object example

```json
{
  "dealType": "sprzedaz",
  "propertyType": "mieszkanie",
  "region": "cala-polska",
  "ownerType": "ALL",
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Sale and rental listings collected from Otodom.

# 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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "PL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/otodom-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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/otodom-scraper").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 '{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}' |
apify call haketa/otodom-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/otodom-scraper"
        }
    }
}
```

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/piCqOG9QF821cJeXR/builds/Nx55aJKt0Gob2W4sm/openapi.json