# Otodom.pl Scraper (`solidcode/otodom-pl-scraper`) Actor

\[💰 $0.95 / 1K] Extract real-estate listings from Otodom.pl. Get prices, area, rooms, addresses, photos, agent contacts, and full descriptions for apartments, houses, plots, and commercial properties — both for sale and for rent — across Poland.

- **URL**: https://apify.com/solidcode/otodom-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 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.

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

## Otodom.pl Scraper

Pull real-estate listings from Otodom.pl at scale — prices in PLN, exact lat/lon coordinates, full Polish-language descriptions, agent phone numbers, agency contacts, and 20+ photos per listing for every for-sale and rental property across Poland. Built for real-estate investors, relocation services, proptech platforms, and market analysts who need fresh Otodom data without manually clicking through a Polish-language portal one voivodeship at a time.

### Why This Scraper?

- **All 16 Polish voivodeships in one actor** — search Mazowieckie, Małopolskie, Pomorskie, Wielkopolskie, Śląskie, Dolnośląskie, or any of the 16 regions by name and the scraper expands to every city inside.
- **Nine property types under one input** — apartments (mieszkanie), studios (kawalerka), houses (dom), plots (działka), commercial premises, halls & warehouses, garages, rooms, and new-build developments (Inwestycje) — flip a single dropdown to switch.
- **Sale and rent in the same run** — toggle `dealType` between `sale` and `rent` without rewriting your URL list; the deal-type and monthly rent both land in clearly labelled fields.
- **Exact lat/lon coordinates on every detail page** — decimal-degree latitude and longitude pulled per listing, not the city-centroid approximation other Otodom scrapers settle for.
- **Pre-revealed phone numbers and agency contacts** — agent and agency phone numbers come back attached to every row when listing details are on, no "Pokaż numer" click-through required.
- **Seven sort orders and seven search radii** — newest, oldest, price ascending/descending, area ascending/descending, plus the Otodom default, paired with a 0/5/10/15/25/50/75-km radius expansion around any city.
- **Granular filter stack** — price range in PLN, area range in m², construction-year range, six room-count buckets (1/2/3/4/5/6+), and search radius all combine in a single call.
- **Paste any Otodom URL** — drop a `/pl/oferty/`, `/pl/wyniki/`, or `/pl/oferta/` link straight from your browser; the scraper reads every filter the URL carries and replicates exactly what you see on the site.
- **Two-stage enrichment with a cost switch** — leave `includeListingDetails` on for the full description, coordinates, year built, and phones, or flip it off for faster, cheaper search-only runs.

### Use Cases

**Real-Estate Investment Research**
- Compare price per m² across Warszawa, Kraków, Wrocław, and Gdańsk to spot under-priced markets
- Track newly listed properties under a price ceiling to find investment-grade flats
- Build comp sets by district using exact lat/lon coordinates and area filters
- Monitor distressed sale signals by sorting newest with a tight price ceiling

**Market Analysis & Trends**
- Map inventory by voivodeship, city, or district to size each regional market
- Compare apartments vs houses vs commercial premises across the same city
- Pull recently bumped listings (`pushedUpAt`) to gauge active seller behaviour
- Build PLN price-per-m² time series from repeated daily or weekly runs

**Lead Generation for Agents**
- Build agency-and-agent contact lists with names, phone numbers, and agency URLs
- Target private sellers (`ownerType: "private"`) for direct buyer-side outreach
- Filter for exclusive offers (`isExclusiveOffer`) to surface premium-listing agencies
- Identify new-build developers via the Inwestycje (investment) property type

**Relocation & Expat Services**
- Pull rental apartments in Warszawa, Kraków, or Wrocław with full Polish descriptions
- Filter by district within a city (Ursynów, Mokotów, Kazimierz) for neighborhood briefs
- Surface listings within a 25 km radius for car-commute relocation candidates
- Combine `searchRadiusKm` with construction year to target modern buildings only

**Proptech & Comparison Engines**
- Power Polish property aggregators with daily-refreshed Otodom inventory
- Enrich existing property records with coordinates, photos, and tag arrays
- Feed pricing dashboards with PLN, price-per-m², area, and rooms in flat schema
- Build alerting systems on new listings under specific price/area filters

**Academic & Government Research**
- Assemble PLN housing-price datasets for Polish urban-planning research
- Quantify regional supply by voivodeship for affordability studies
- Track construction year to map building-stock age across cities
- Power journalism on rental-market squeeze with verifiable per-listing data

### Getting Started

#### Quick Start — One City

The simplest possible run — apartments for sale in Warszawa:

```json
{
    "locations": ["Warszawa"],
    "maxResults": 100
}
````

#### Filtered Search — Mid-Market Apartments

Apartments for sale in Warszawa, 40–80 m², priced between 500k and 1M PLN, with 2 or 3 rooms:

```json
{
    "locations": ["Warszawa"],
    "dealType": "sale",
    "propertyType": "apartment",
    "minPrice": 500000,
    "maxPrice": 1000000,
    "minArea": 40,
    "maxArea": 80,
    "roomsCount": ["2", "3"],
    "maxResults": 200
}
```

#### Paste an Otodom URL

Drop any Otodom search or listing URL directly — every filter in the URL is preserved:

```json
{
    "startUrls": [
        "https://www.otodom.pl/pl/oferty/sprzedaz/mieszkanie/sopot?priceMin=500000&priceMax=2000000",
        "https://www.otodom.pl/pl/oferta/przepiekne-mieszkanie-3-pokojowe-ID4xY7w"
    ],
    "maxResults": 300
}
```

#### Multi-City Rentals with Full Filters

Rent apartments across Warszawa and Kraków, newest first, within 10 km of each centre, including the full detail enrichment:

```json
{
    "locations": ["Warszawa", "Kraków"],
    "dealType": "rent",
    "propertyType": "apartment",
    "maxPrice": 6000,
    "minArea": 35,
    "roomsCount": ["2", "3"],
    "searchRadiusKm": "10",
    "sortBy": "newest",
    "includeListingDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Otodom.pl search or listing URLs. The scraper auto-detects deal type, property type, location, and any filters embedded in the URL. When URLs are present, the filter settings below are ignored. |
| `locations` | string\[] | `["Warszawa"]` | Cities, districts, regions, or voivodeships to search (e.g. "Warszawa", "Kraków", "Ursynów", "mazowieckie"). Polish names work best. |

#### Search Filters

These apply to the `locations` list. When using `startUrls`, every filter comes from the URL itself.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dealType` | select | `For Sale` | For Sale or For Rent. |
| `propertyType` | select | `Apartments` | Apartments, Studio apartments, Houses, New-build developments, Rooms, Plots / Land, Commercial premises, Halls and warehouses, or Garages. |
| `minPrice` | integer | null | Lowest listing price in PLN. |
| `maxPrice` | integer | null | Highest listing price in PLN. |
| `minArea` | integer | null | Smallest floor area in m². |
| `maxArea` | integer | null | Largest floor area in m². |
| `minYearBuilt` | integer | null | Earliest construction year (1800–2100). |
| `maxYearBuilt` | integer | null | Latest construction year (1800–2100). |
| `roomsCount` | select\[] | `[]` | 1 room, 2 rooms, 3 rooms, 4 rooms, 5 rooms, or 6+ rooms. Leave empty for any. |
| `searchRadiusKm` | select | `Exact area only (0 km)` | Expand each location by 0, 5, 10, 15, 25, 50, or 75 km. |
| `sortBy` | select | `Otodom default` | Default, Newest first, Oldest first, Price lowest first, Price highest first, Area smallest first, or Area largest first. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum total listings across all URLs and locations. Set to `0` for unlimited (capped at 50,000 for safety). |
| `includeListingDetails` | boolean | `true` | When on, every listing is enriched with full description, agent phone numbers, exact lat/lon coordinates, district, year built, and the complete photo gallery. Turn off for faster, thinner search-only runs. |

### Output

Every row is a single flat listing. With `includeListingDetails` on, you get the full per-property record below:

```json
{
    "id": "76498234",
    "url": "https://www.otodom.pl/pl/oferta/przepiekne-mieszkanie-3-pokojowe-ID4xY7w",
    "title": "Przepiękne 3-pokojowe mieszkanie z balkonem | Mokotów",
    "slug": "przepiekne-mieszkanie-3-pokojowe-ID4xY7w",
    "dealType": "sale",
    "propertyType": "apartment",
    "transaction": "SELL",
    "estate": "FLAT",
    "price": 849000,
    "priceFormatted": "849 000 zł",
    "currency": "PLN",
    "pricePerSqm": 14150,
    "rentPrice": null,
    "hidePrice": false,
    "areaSqm": 60,
    "terrainAreaSqm": null,
    "rooms": 3,
    "floor": "4",
    "yearBuilt": 2018,
    "street": "ul. Puławska",
    "district": "Mokotów",
    "city": "Warszawa",
    "province": "mazowieckie",
    "latitude": 52.1956,
    "longitude": 21.0344,
    "locationPath": ["Polska", "mazowieckie", "Warszawa", "Mokotów"],
    "description": "Do sprzedaży przepiękne 3-pokojowe mieszkanie zlokalizowane w sercu Mokotowa. Powierzchnia 60 m², 4. piętro z windą, balkon...",
    "shortDescription": "3 pokoje, 60 m², Mokotów — gotowe do wprowadzenia.",
    "images": [
        "https://ireland.apollo.olxcdn.com/v1/files/large/abc123.jpg",
        "https://ireland.apollo.olxcdn.com/v1/files/large/def456.jpg"
    ],
    "imagesCount": 24,
    "tags": ["balkon", "winda", "klimatyzacja", "miejsce parkingowe"],
    "ownerName": "Anna Kowalska",
    "ownerType": "agency",
    "ownerContacts": {
        "phone": "+48 600 123 456",
        "phones": ["+48 600 123 456"]
    },
    "agencyName": "Premium Real Estate Warszawa",
    "agencyUrl": "https://www.otodom.pl/pl/firmy/biura-nieruchomosci/premium-real-estate",
    "agencyAddress": "Złota 44/402, 00-120, Warszawa, mazowieckie",
    "agencyPhone": "+48 22 123 45 67",
    "agencyPhones": ["+48 22 123 45 67"],
    "agencyLicenseNumber": "12345",
    "isPrivateOwner": false,
    "isExclusiveOffer": true,
    "isPromoted": false,
    "publishedAt": "2026-04-12T09:34:21Z",
    "pushedUpAt": "2026-05-11T07:12:00Z",
    "scrapedAt": "2026-05-16T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Stable Otodom listing ID |
| `url` | string | Public listing URL on otodom.pl |
| `title` | string | Listing title as shown on the site (Polish) |
| `slug` | string | URL-safe identifier from the listing path |
| `dealType` | string | `sale` or `rent` |
| `propertyType` | string | One of the nine supported types |
| `transaction` | string | Raw transaction code (`SELL`, `RENT`) |
| `estate` | string | Raw estate code (`FLAT`, `HOUSE`, `TERRAIN`, etc.) |
| `scrapedAt` | string | ISO 8601 timestamp when the row was collected |

#### Price & Sizing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Listing price as a number |
| `priceFormatted` | string | Price as shown ("849 000 zł") |
| `currency` | string | Always `PLN` for housing listings; may differ on some commercial premises |
| `pricePerSqm` | number | Computed price per m² (PLN/m²) |
| `rentPrice` | number | Monthly rent when `dealType=rent` (PLN) |
| `hidePrice` | boolean | True when the seller hides the price |
| `areaSqm` | number | Floor area in m² |
| `terrainAreaSqm` | number | Plot area in m² (houses, plots) |
| `rooms` | integer | Room count |
| `floor` | string | Floor designation (e.g. "3", "ground", "attic") |
| `yearBuilt` | integer | Construction year |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | Street name |
| `district` | string | District / neighborhood |
| `city` | string | City name |
| `province` | string | Voivodeship (Polish region) |
| `latitude` | number | Latitude in decimal degrees |
| `longitude` | number | Longitude in decimal degrees |
| `locationPath` | string\[] | Hierarchy from country → voivodeship → city → district |

#### Description & Media

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full listing description (Polish, can be long) |
| `shortDescription` | string | Snippet shown in search results |
| `images` | string\[] | Large-resolution image URLs |
| `imagesCount` | integer | Total number of images on the listing |
| `tags` | string\[] | Feature tags (e.g. "balkon", "winda", "klimatyzacja") |

#### Contact & Agency

| Field | Type | Description |
|-------|------|-------------|
| `ownerName` | string | Agent or private-owner name |
| `ownerType` | string | `agency`, `private`, or `developer` |
| `ownerContacts` | object | `{ phone, phones }` when published. Otodom does not publish email addresses, so no email field is included. |
| `agencyName` | string | Agency name when applicable |
| `agencyUrl` | string | Agency profile URL on Otodom |
| `agencyAddress` | string | Agency office address (Polish postal format) |
| `agencyPhone` | string | Primary agency phone number |
| `agencyPhones` | string\[] | All agency phone numbers (line + mobile, when published) |
| `agencyLicenseNumber` | string | Polish real-estate license number (verification signal) |
| `isPrivateOwner` | boolean | True when listed by a private owner |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `isExclusiveOffer` | boolean | True for exclusive listings |
| `isPromoted` | boolean | True for promoted / sponsored slots |
| `publishedAt` | string | When the listing was first published (ISO 8601) |
| `pushedUpAt` | string | When the listing was last bumped to the top (ISO 8601) |

When `includeListingDetails` is off, `description`, `latitude`, `longitude`, `district`, `yearBuilt`, `ownerContacts`, and the full photo gallery come back empty — the run is noticeably faster and cheaper.

### Tips for Best Results

- **Use Polish voivodeship names for region-wide pulls** — typing `mazowieckie` or `małopolskie` in `locations` expands to every city in that region. Polish spellings with diacritics work fine; the scraper normalises them.
- **Combine `searchRadiusKm` with a tight city for commuter belts** — set `locations: ["Warszawa"]` plus `searchRadiusKm: "25"` to pull every flat within 25 km of central Warszawa, including Legionowo, Józefów, and other suburbs.
- **Turn off `includeListingDetails` for inventory scans** — when you only need price, area, rooms, and city for trend analysis, the search-only mode is ~40% faster and skips the per-listing detail fetch entirely.
- **Use `sortBy: "newest"` for daily monitoring** — combined with a small `maxResults` (50–100), it surfaces only the listings posted since your last run.
- **Paste a filtered URL from your browser** — set up the search visually on otodom.pl, copy the URL, and drop it into `startUrls`. Every filter — price, area, rooms, even map polygons — is preserved.
- **For rentals, pair `dealType: "rent"` with `maxPrice` in PLN** — typical Warszawa rental ceiling is 4,000–8,000 PLN/month; use `maxPrice: 6000` to get the mid-market band.
- **Start with `maxResults: 100` to verify your filters** — Otodom's filter URL encoding is strict; a 100-row test run confirms the price/area/rooms filters actually fired before you scale to 10,000.

### Pricing

**$0.95 per 1,000 results** — flat per-result pricing for the largest Polish real-estate portal, including full descriptions, lat/lon coordinates, and agent phone numbers.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.10 |
| 1,000 | $0.95 |
| 10,000 | $9.50 |
| 100,000 | $95.00 |

No compute charges — you only pay per result returned. A "result" is one listing row in the output dataset.

### 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 listings
- **Webhooks** — Trigger custom APIs on run completion
- **Power BI** / **Tableau** / **Looker** — Property analyst dashboards
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate real-estate research, market analysis, relocation services, and lead generation. Users are responsible for complying with applicable laws, GDPR for any personal data captured, and Otodom.pl's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose. Phone numbers and agent contacts are published by the listing party — use them only for legitimate property inquiries.

# Actor input Schema

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

Paste one or more Otodom.pl search or listing URLs directly. The scraper auto-detects the deal type, property type, location, and any filters embedded in the URL. When URLs are provided here, the filter settings below are ignored — everything comes from the URL itself.

## `locations` (type: `array`):

Cities, districts, regions, or voivodeships to search (e.g. "Warszawa", "Kraków", "Ursynów", "mazowieckie"). Polish names work best. Leave empty if using Start URLs.

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

Whether to find properties for sale or for rent. Ignored when using Start URLs.

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

The kind of property to find.

## `minPrice` (type: `integer`):

Lowest listing price to include, in Polish zloty (PLN). Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Highest listing price to include, in Polish zloty (PLN). Leave empty for no maximum.

## `minArea` (type: `integer`):

Smallest floor area to include, in square meters. Leave empty for no minimum.

## `maxArea` (type: `integer`):

Largest floor area to include, in square meters. Leave empty for no maximum.

## `minYearBuilt` (type: `integer`):

Earliest construction year to include. Leave empty for no minimum.

## `maxYearBuilt` (type: `integer`):

Latest construction year to include. Leave empty for no maximum.

## `roomsCount` (type: `array`):

Only include listings with these room counts. Leave empty to include any room count.

## `searchRadiusKm` (type: `string`):

Expand each location to include listings within this many kilometers of the center. Choose 0 to limit results strictly to the named area.

## `sortBy` (type: `string`):

How to order the results.

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

Maximum total listings to return across all URLs and locations combined. Set to 0 for unlimited (capped at 50,000 for safety). Tip: start with 50–100 to test, then increase.

## `includeListingDetails` (type: `boolean`):

When ON (default), each listing is enriched with the full detail page — agent phone numbers, full description, district, year built, coordinates (latitude/longitude), and the complete photo gallery. Turn OFF to skip detail pages: results are returned faster and cheaper, but description, phones, and coordinates will be empty.

## Actor input object example

```json
{
  "startUrls": [],
  "locations": [
    "Warszawa"
  ],
  "dealType": "sale",
  "propertyType": "apartment",
  "roomsCount": [],
  "searchRadiusKm": "0",
  "sortBy": "default",
  "maxResults": 100,
  "includeListingDetails": true
}
```

# Actor output Schema

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

Table of listings with the most useful fields — deal type, price, area, rooms, location.

## `details` (type: `string`):

Full per-listing detail rows including agency, contacts, tags, and coordinates.

# 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": [],
    "locations": [
        "Warszawa"
    ],
    "dealType": "sale",
    "propertyType": "apartment",
    "roomsCount": [],
    "searchRadiusKm": "0",
    "sortBy": "default",
    "maxResults": 100,
    "includeListingDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/otodom-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 = {
    "startUrls": [],
    "locations": ["Warszawa"],
    "dealType": "sale",
    "propertyType": "apartment",
    "roomsCount": [],
    "searchRadiusKm": "0",
    "sortBy": "default",
    "maxResults": 100,
    "includeListingDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/otodom-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 '{
  "startUrls": [],
  "locations": [
    "Warszawa"
  ],
  "dealType": "sale",
  "propertyType": "apartment",
  "roomsCount": [],
  "searchRadiusKm": "0",
  "sortBy": "default",
  "maxResults": 100,
  "includeListingDetails": true
}' |
apify call solidcode/otodom-pl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Otodom.pl Scraper",
        "description": "[💰 $0.95 / 1K] Extract real-estate listings from Otodom.pl. Get prices, area, rooms, addresses, photos, agent contacts, and full descriptions for apartments, houses, plots, and commercial properties — both for sale and for rent — across Poland.",
        "version": "1.0",
        "x-build-id": "ppa6yxfSUVRWndGJH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~otodom-pl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-otodom-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~otodom-pl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-otodom-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~otodom-pl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-otodom-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste one or more Otodom.pl search or listing URLs directly. The scraper auto-detects the deal type, property type, location, and any filters embedded in the URL. When URLs are provided here, the filter settings below are ignored — everything comes from the URL itself.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, districts, regions, or voivodeships to search (e.g. \"Warszawa\", \"Kraków\", \"Ursynów\", \"mazowieckie\"). Polish names work best. Leave empty if using Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Whether to find properties for sale or for rent. Ignored when using Start URLs.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "apartment",
                            "studio",
                            "house",
                            "investment",
                            "room",
                            "plot",
                            "commercial",
                            "hall",
                            "garage"
                        ],
                        "type": "string",
                        "description": "The kind of property to find.",
                        "default": "apartment"
                    },
                    "minPrice": {
                        "title": "Minimum Price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest listing price to include, in Polish zloty (PLN). Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest listing price to include, in Polish zloty (PLN). Leave empty for no maximum."
                    },
                    "minArea": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Smallest floor area to include, in square meters. Leave empty for no minimum."
                    },
                    "maxArea": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Largest floor area to include, in square meters. Leave empty for no maximum."
                    },
                    "minYearBuilt": {
                        "title": "Minimum Year Built",
                        "minimum": 1800,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Earliest construction year to include. Leave empty for no minimum."
                    },
                    "maxYearBuilt": {
                        "title": "Maximum Year Built",
                        "minimum": 1800,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Latest construction year to include. Leave empty for no maximum."
                    },
                    "roomsCount": {
                        "title": "Room Counts",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include listings with these room counts. Leave empty to include any room count.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6plus"
                            ],
                            "enumTitles": [
                                "1 room",
                                "2 rooms",
                                "3 rooms",
                                "4 rooms",
                                "5 rooms",
                                "6 or more rooms"
                            ]
                        },
                        "default": []
                    },
                    "searchRadiusKm": {
                        "title": "Search Radius",
                        "enum": [
                            "0",
                            "5",
                            "10",
                            "15",
                            "25",
                            "50",
                            "75"
                        ],
                        "type": "string",
                        "description": "Expand each location to include listings within this many kilometers of the center. Choose 0 to limit results strictly to the named area.",
                        "default": "0"
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "default",
                            "newest",
                            "oldest",
                            "priceLowest",
                            "priceHighest",
                            "areaSmallest",
                            "areaLargest"
                        ],
                        "type": "string",
                        "description": "How to order the results.",
                        "default": "default"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings to return across all URLs and locations combined. Set to 0 for unlimited (capped at 50,000 for safety). Tip: start with 50–100 to test, then increase.",
                        "default": 100
                    },
                    "includeListingDetails": {
                        "title": "Include full listing details",
                        "type": "boolean",
                        "description": "When ON (default), each listing is enriched with the full detail page — agent phone numbers, full description, district, year built, coordinates (latitude/longitude), and the complete photo gallery. Turn OFF to skip detail pages: results are returned faster and cheaper, but description, phones, and coordinates will be empty.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
