# Nieruchomosci-online.pl Scraper (`crawlerbros/nieruchomosci-online-scraper`) Actor

Scrape Nieruchomosci-online.pl - one of Poland's largest real estate portals. Search properties for sale or rent in any Polish city, browse new-build developer projects or agency/developer directories, or fetch full listing details by URL.

- **URL**: https://apify.com/crawlerbros/nieruchomosci-online-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Nieruchomosci-online.pl Scraper

Scrape **Nieruchomosci-online.pl** — one of Poland's largest real estate portals. Search apartments, houses, plots, rooms and commercial property for sale or rent in any Polish city, browse nationwide new-build developer projects, browse the site's real estate agency and developer-company directories, or fetch full details (amenities, floor plan facts, agent contact, GPS coordinates) for a specific listing or project URL. HTTP-only, no auth, no proxy required.

### What this actor does

- **Five modes:** `search` (by city + property type + transaction type), `investments` (nationwide new-build developer projects, optionally narrowed by city/price), `agencies` (real estate agency directory, nationwide or one city), `developers` (developer company directory, nationwide or one city), and `byUrl` (direct listing or project lookup)
- **6 property types × 2 transaction types:** apartments, rooms, houses, plots/land, commercial premises, commercial buildings — for sale or for rent
- **Client-side filters:** city scope, price range (PLN), room count range, size range (m²) — applied against every listing so results always respect your bounds even when the source's own search/filter widgets don't
- **7 sort orders:** newest, price (asc/desc), price per m² (asc/desc), area (asc/desc)
- **Rich detail mode:** amenities, building facts (year built, floors, building type), GPS coordinates, agent contact, and more when you supply listing or project URLs directly
- **Business directories:** agency/developer name, profile URL, phone, address, city, short description and listing/project counts — useful for lead-gen or partner research
- **Empty fields are omitted**

### Output per listing (mode = `search`)

- `title`, `description`
- `price` (PLN), `pricePerM2` (PLN), `currency`
- `rooms`, `size` (m²)
- `address`, `city`, `region`, `country`
- `imageUrl`
- `propertyType`, `transactionType`
- `url`
- `recordType: "listing"`, `scrapedAt`

### Output per project (mode = `investments`)

Developer new-build projects from the site's `/inwestycje/` hub — each record is a whole multi-unit development, so `price`/`pricePerM2` are the project's *starting* price (the source's own "od \<price> zł" framing), not one flat's exact price. Fetch the project's own `url` via `mode=byUrl` for full per-project facts (unit count, amenities, year built).

- `title` (the source's own price-teaser headline, e.g. "Mieszkania od 629 000 zł do 849 000 zł")
- `price` (PLN, starting price), `pricePerM2` (PLN), `currency`
- `address`, `city`, `region`, `country`
- `imageUrl`
- `category` (`"Inwestycje"`)
- `url`
- `recordType: "investment"`, `scrapedAt`

### Output per listing (mode = `byUrl`)

- `title`, `description`
- `price` (PLN), `pricePerM2` (PLN), `currency`
- `rooms`, `bathrooms`, `size` (m²), `floorLevel`, `yearBuilt`
- `address`, `city`, `region`, `country`, `latitude`, `longitude`
- `amenities[]` — e.g. Parking, Elevator, Balcony, Garage, WiFi
- `details` — extra structured facts that vary by property type (e.g. `totalFloors`, `buildingType`, `landArea`, `landType` for plots; `numberOfUnits`, `unitMix`, `yearBuilt` for developer projects)
- `availableUnits` — currently-available unit count (developer-project pages only)
- `images[]`
- `agentName`, `agentAddress`
- `datePosted`
- `category`, `transactionLabel` — Polish labels from the site's own breadcrumb (e.g. `category: "Inwestycje"` for a developer-project URL instead of a property-type label)
- `url`
- `recordType: "listingDetail"`, `scrapedAt`

`listingUrls` accepts both ordinary listing URLs (`.../mieszkanie,na-sprzedaz/26869247.html`) and developer-project URLs (`.../smetna-garden.html`) — both are the same JSON-LD detail-page shape the site publishes.

### Output per entry (mode = `agencies` or `developers`)

From the site's `/biura-nieruchomosci/` (agencies) and `/deweloperzy/` (developer companies) directories — nationwide by default, or scoped to one city's own directory subdomain when `city` is set.

- `name` — company/office name
- `phone`
- `address`, `city`
- `description` — the source's own short bio text (sometimes truncated with `(...)`, as shown on the site)
- `listingCount` (mode=agencies) — current number of active listings
- `projectCount` (mode=developers) — current number of active developer projects
- `isProAgent` — present (`true`) only when the source shows its "Profesjonalny Agent" quality badge; omitted otherwise
- `category` (`"Biuro nieruchomości"` or `"Deweloper"`)
- `url` — the company's own profile subdomain
- `recordType: "agency"` / `"developer"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `investments` / `agencies` / `developers` / `byUrl` |
| `city` | string | `Warszawa` | Polish city or town name. Required scope for `search`; optional narrowing filter for `investments`/`agencies`/`developers` (clear it for nationwide) |
| `propertyType` | string | `mieszkanie` | Apartment / room / house / plot / commercial premises / commercial building (mode=search) |
| `transactionType` | string | `sprzedaz` | For sale / for rent (mode=search) |
| `sortBy` | string | `newest` | Newest / price asc-desc / price-per-m² asc-desc / area asc-desc (mode=search) |
| `minPrice` / `maxPrice` | int | – | Price range in PLN (mode=search or mode=investments) |
| `minRooms` / `maxRooms` | int | – | Room count range (mode=search) |
| `minSize` / `maxSize` | int | – | Size range in m² (mode=search) |
| `listingUrls` | array | – | Listing or developer-project URLs to fetch (mode=byUrl) |
| `maxItems` | int | `20` | Hard cap (1–2000) |

#### Example: apartments for sale in Warsaw, 2–3 rooms under 800 000 PLN

```json
{
  "mode": "search",
  "city": "Warszawa",
  "propertyType": "mieszkanie",
  "transactionType": "sprzedaz",
  "minRooms": 2,
  "maxRooms": 3,
  "maxPrice": 800000,
  "sortBy": "price_asc",
  "maxItems": 30
}
```

#### Example: full details for specific listings or developer projects

```json
{
  "mode": "byUrl",
  "listingUrls": [
    "https://warszawa.nieruchomosci-online.pl/mieszkanie,na-sprzedaz/26869247.html",
    "https://krakow.nieruchomosci-online.pl/smetna-garden.html"
  ]
}
```

#### Example: nationwide new-build developer projects under 700 000 PLN

```json
{
  "mode": "investments",
  "city": "",
  "maxPrice": 700000,
  "maxItems": 30
}
```

#### Example: real estate agencies in Warsaw

```json
{
  "mode": "agencies",
  "city": "Warszawa",
  "maxItems": 30
}
```

#### Example: developer companies nationwide

```json
{
  "mode": "developers",
  "city": "",
  "maxItems": 30
}
```

### Use cases

- **PropTech & market analytics** — track asking-price trends by city, property type and room count
- **Investment & new-build research** — scan plots, commercial buildings and nationwide developer projects for development opportunities, and monitor starting prices and unit availability
- **Relocation services** — build curated listing digests for clients moving to a Polish city
- **Rental market monitoring** — compare rent levels across cities and neighborhoods
- **Lead generation for agents** — discover fresh private-seller listings by transaction type
- **Partner/vendor research** — build a contact list of active real estate agencies or developer companies in a target city

### FAQ

**What's the data source?** The public search, `/inwestycje/` (developer projects hub), `/biura-nieruchomosci/` and `/deweloperzy/` (business directories), and listing/project detail pages of [nieruchomosci-online.pl](https://www.nieruchomosci-online.pl). Listing/investment/detail data is parsed from the structured data (JSON-LD) each page publishes for search engines; the agency/developer directories don't publish JSON-LD, so those two modes parse the same directory-card HTML the site renders server-side.

**How does city-scoping work for `mode=agencies`/`mode=developers`?** The actor first requests the city's own directory subdomain (e.g. `warszawa.nieruchomosci-online.pl/biura-nieruchomosci/`) to narrow the scan server-side, then — same as `search`/`investments` — applies a strict client-side match against each entry's own `city` field before emitting it. This second step is necessary: verified via testing that a city-scoped `/deweloperzy/` subdomain page can also list developers based in a nearby town or a different city in the same voivodeship, so relying on the subdomain alone would leak out-of-scope results. If a city has no matching entries (or the name doesn't resolve to a real directory subdomain), the actor emits 0 records with a clear status message rather than guessing or fabricating a match — try clearing `city` for the nationwide directory instead.

**Why does `developers` sometimes omit `projectCount`?** A minority of developer-directory cards don't render a project counter on the source page at all (typically a company with 0 currently-listed projects) — the field is simply omitted rather than showing a fabricated `0`.

**Is this affiliated with Nieruchomosci-online.pl?** No — this is an independent third-party actor that reads publicly available pages.

**Why are `city`/`minPrice`/`maxPrice`/`minRooms`/`maxRooms`/`minSize`/`maxSize` applied "client-side"?** The site's own search broadens results to nearby towns/villages in the same voivodeship (e.g. searching `Warszawa` can also return listings in `Otwock`), and its price/room/size filter widgets — including the market-type (primary/secondary), building-type, construction-year and room-capacity dropdowns — require JavaScript and are silently ignored by a plain URL request (verified: passing their query parameters directly returns the identical unfiltered page). So the actor fetches the (city + property type + transaction type) result pages and applies your `city` and numeric bounds itself, page by page, until `maxItems` is reached or the search is exhausted. This guarantees every returned record genuinely matches your filters, including `city`.

**Why do some listings have no `price`?** New-development marketing cards (mode=`search`/`investments`) sometimes leave `price`/`size` blank on the search-result card itself — the actor detects this and automatically fetches that listing's own detail page to backfill the real figures (same data `mode=byUrl` returns), so this happens transparently in the vast majority of cases. Only the rare listing that has genuinely never published a price anywhere on the site (even its own detail page) ends up with the field omitted rather than a fabricated placeholder.

**Can I search a district/neighborhood within a city?** Not currently — only city-level search is supported. District/street are still returned as part of `address` when available.

**What is `mode=investments`?** It browses the site's dedicated `/inwestycje/` hub — brand-new multi-unit developments from developers, listed nationwide. Each record represents a whole project (not one flat), so `price`/`pricePerM2` are the project's advertised *starting* price. The hub doesn't support server-side city scoping, so — same as `search` — `city` is applied client-side as an optional narrowing filter over the nationwide feed; clear the `city` field for unfiltered nationwide results. `minRooms`/`maxRooms`/`minSize`/`maxSize`/`sortBy` aren't offered for this mode since a project spans many unit sizes/layouts rather than one, and the hub doesn't support sorting.

**How fresh is the data?** Listings and projects are scraped live on every run — pricing, availability and descriptions reflect what's currently published on the site.

**Is a proxy or login required?** No — the actor works entirely over plain HTTP with no authentication or paid proxy.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `city` (type: `string`):

Polish city or town name, e.g. `Warszawa`, `Krakow`, `Wroclaw`, `Gdansk`, `Poznan`. Required scope for mode=search. For mode=investments/agencies/developers it's an optional narrowing filter — clear it for nationwide results.

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

Type of property to search (mode=search).

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

Sale or rent (mode=search).

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

Result ordering (mode=search).

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

Drop listings priced below this (PLN). Applied client-side against each record's price (mode=search or mode=investments; for investments this is the project's starting price).

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

Drop listings priced above this (PLN). Applied client-side against each record's price (mode=search or mode=investments; for investments this is the project's starting price).

## `minRooms` (type: `integer`):

Drop listings with fewer rooms than this. Only meaningful for apartments/houses/rooms; plots and buildings without a room count always pass through (mode=search).

## `maxRooms` (type: `integer`):

Drop listings with more rooms than this (mode=search).

## `minSize` (type: `integer`):

Drop listings smaller than this (m²) (mode=search).

## `maxSize` (type: `integer`):

Drop listings larger than this (m²) (mode=search).

## `listingUrls` (type: `array`):

Full nieruchomosci-online.pl listing URLs, e.g. `https://warszawa.nieruchomosci-online.pl/mieszkanie,na-sprzedaz/26869247.html`.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "city": "Warszawa",
  "propertyType": "mieszkanie",
  "transactionType": "sprzedaz",
  "sortBy": "newest",
  "listingUrls": [],
  "maxItems": 20
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped listings.

# 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 = {
    "mode": "search",
    "city": "Warszawa",
    "propertyType": "mieszkanie",
    "transactionType": "sprzedaz",
    "sortBy": "newest",
    "listingUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/nieruchomosci-online-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 = {
    "mode": "search",
    "city": "Warszawa",
    "propertyType": "mieszkanie",
    "transactionType": "sprzedaz",
    "sortBy": "newest",
    "listingUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/nieruchomosci-online-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 '{
  "mode": "search",
  "city": "Warszawa",
  "propertyType": "mieszkanie",
  "transactionType": "sprzedaz",
  "sortBy": "newest",
  "listingUrls": [],
  "maxItems": 20
}' |
apify call crawlerbros/nieruchomosci-online-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/nieruchomosci-online-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/4QwbC2G3OvAjVHpCe/builds/erf4fXBgBaEDF4iIe/openapi.json