# Nieruchomosci-online Property & Agency Directory Scraper (`vexaloom-labs/nieruchomosci-online-property-and-agency-directory`) Actor

Search Nieruchomosci-online.pl properties for sale or rent in any Polish city, browse nationwide new-build developer projects or the agency/developer directories, or fetch full listing details by URL.

- **URL**: https://apify.com/vexaloom-labs/nieruchomosci-online-property-and-agency-directory.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/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

## Nieruchomosci-online Property & Agency Directory Scraper

Nieruchomosci-online.pl is one of Poland's largest independent real estate portals, pairing property listings with its own directories of agencies and developer companies. This actor searches apartments, houses, plots, rooms and commercial property for sale or rent in any Polish city, browses nationwide new-build developer projects, browses the agency and developer-company directories, or fetches full details (amenities, floor plan facts, agent contact, GPS coordinates) for a specific listing or project URL. No account is 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²), `floorLevel`, `yearBuilt`
- `address`, `city`, `district`, `region`, `country`
- `latitude`, `longitude`
- `imageUrl`
- `sellerType` (`agency` / `private` / `developer` / `company`), `agencyName`, `agentName`, `agentPhone`, `agentUrl`, `isProAgent`, `noCommission`
- `marketType` (`primary` / `secondary`), `dateModified`
- `details` — extra card facts such as `totalFloors`, `conditionType`, `parkingType`, `garageType`, `completionDate`
- `virtualTourUrl`, `videoUrl` when the listing publishes them
- `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`, `district`, `region`, `country`, `latitude`, `longitude`
- `imageUrl`
- `developerName`, `developerUrl`, `salesOfficeName`, `salesOfficeAddress`, `salesOfficeCity`, `salesOfficePostalCode`, `agentPhone`
- `availableUnits` — currently advertised unit count
- `sellerType` (`developer`), `marketType` (`primary`), `dateModified`
- `category` (`"Inwestycje"`)
- `virtualTourUrl`, `videoUrl` when published
- `url`
- `recordType: "investment"`, `scrapedAt`

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

- `title`, `description`
- `price` (PLN), `pricePerM2` (PLN), `currency`
- `rooms`, `bedrooms`, `bathrooms`, `size` (m²), `floorLevel`, `yearBuilt`
- `address`, `city`, `district` where available, `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`, `agentPhone`
- `sellerType`, `marketType`
- `virtualTourUrl`, `videoUrl` when published
- `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) |
| `sellerType` | string | `any` | `any` / `agency` / `private` / `developer` / `company` — keeps only offers from that seller type (mode=search; every investment project is a developer) |
| `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 as an input filter — the site's district filter needs JavaScript and is not applied server-side. `district` (e.g. `Ochota`, `Nowa Huta`) is extracted and returned on every listing where the source publishes it, so you can filter the dataset by district after the run. `address` and `city` are also returned as separate fields.

**What does `sellerType` mean?** The source labels every card with a publisher type. The actor normalizes it to `agency`, `private` (ad placed directly by the owner), `developer` (new-build project) or `company`, and exposes it as `sellerType`. Set `sellerType: "private"` to keep only owner-placed offers, or `agency` to exclude private sellers.

**Do I get the full photo gallery?** Search and investment cards publish only the cover photo (`imageUrl`); the full `images[]` array is returned in `mode=byUrl` from each listing's detail page. Use `byUrl` when you need every photo, the floor plan facts, or the full description.

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

### Limitations

- **District filter:** returned per listing but not accepted as an input filter (the site's own district widget is JavaScript-only). Filter the dataset downstream by `district`.
- **Rows per run:** `maxItems` is capped at 2,000. The actor scans up to 60 result pages and deduplicates by URL, so a broad search returns the first 2,000 unique matches; split by city/property type to reach more.
- **Search-card depth:** `mode=search` and `mode=investments` return the card payload (plus one automatic detail fetch when price/size are blank). Full galleries, amenities and free-text building facts require `mode=byUrl`.
- **Single portal:** this actor covers Nieruchomosci-online.pl only; it does not aggregate Otodom, OLX, Morizon or other portals.

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

## `sellerType` (type: `string`):

Keep only offers published by a given seller type (mode=search; in mode=investments every project is a developer). `any` keeps all sellers. Private means the ad is placed directly by the owner.

## `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",
  "sellerType": "any",
  "listingUrls": [],
  "maxItems": 3
}
```

# 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",
    "sellerType": "any",
    "listingUrls": [],
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/nieruchomosci-online-property-and-agency-directory").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",
    "sellerType": "any",
    "listingUrls": [],
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/nieruchomosci-online-property-and-agency-directory").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",
  "sellerType": "any",
  "listingUrls": [],
  "maxItems": 3
}' |
apify call vexaloom-labs/nieruchomosci-online-property-and-agency-directory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/nieruchomosci-online-property-and-agency-directory"
        }
    }
}
```

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/OtAwo8vgrqKT6Fm6n/builds/lkL2CVJVgcZji40bh/openapi.json
