# Poland Developer Apartment Prices (dane.gov.pl) (`delfielectronics/poland-developer-prices`) Actor

Asking prices of every new-build apartment and house on sale in Poland, from the price lists developers must publish daily on dane.gov.pl. Price per m², area, location, developer, and price changes since your last run.

- **URL**: https://apify.com/delfielectronics/poland-developer-prices.md
- **Developed by:** [Artur Flamandzki](https://apify.com/delfielectronics) (community)
- **Categories:** Real estate
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## Poland Developer Apartment Prices (dane.gov.pl price lists)

Get the **asking price of every new-build apartment and house on sale in Poland**, unit by unit, from the
price lists developers must publish every day under the 2025 price-transparency law. The actor reads the official
open-data files from **dane.gov.pl**, maps the many file variants to one clean record, and tells you **which prices
changed since your last run**.

Every unit becomes one record: developer (name, KRS, NIP, REGON), investment, voivodeship, city and street,
unit number, **total price, price per m², area**, floor, rooms, VAT, the dates the prices apply from, and the
licence and source file of the data.

### What you can use it for

- **Price monitoring**: run it daily and get only new units and price changes (cuts and rises, in PLN and %).
- **Market research and valuation**: price per m² by city, district, developer and investment.
- **Real-estate portals and comparison sites**: a complete, daily list of primary-market offers.
- **Banks, appraisers and investors**: asking-price trends straight from the developers' own filings.
- **AI agents and analytics pipelines**: structured, deduplicated data via the Apify API or MCP.

### How it works

1. The actor lists the price-list files developers sent to dane.gov.pl in the last N days and keeps the newest
   file of each developer dataset (optionally only for the developers you name).
2. Each file (CSV in its many variants) is read and every row becomes one unit record; parking places, storage
   rooms and commercial units are classified, so you can keep only apartments and houses (the default) or ask
   for them.
3. Your filters are applied (voivodeships, cities, property type).
4. Each unit is compared with the price this actor last returned to you: `previous_price_total`, `price_change`,
   `price_change_pct`, `price_changed`, `is_new`. With **Only new units and price changes** on, a scheduled run
   returns only what changed: a ready-made price alert. The memory is kept per combination of filters and for
   90 days after a unit was last seen.

### Input

| Field | What it does |
|---|---|
| Price lists published in the last N days | 1 = yesterday and today (best for a daily schedule); up to 60 |
| Developers | Keep only price lists whose title names these developers (e.g. `Murapol`); also makes runs cheaper |
| Voivodeships | e.g. `mazowieckie`, `małopolskie` (Polish letters optional) |
| Cities | e.g. `Warszawa`, `Kraków` (matches city, municipality or county of the investment) |
| Property type | Apartments and houses (default), apartments, houses, parking, storage, commercial, everything |
| Only new units and price changes | Ideal for daily schedules |
| Max units / Max price-list files | Stop after this many |

### Output example

```json
{
  "unit_key": "20 hex digits, stable per unit",
  "developer_name": "Example Development sp. z o.o.",
  "developer_krs": "0000123456",
  "developer_nip": "1234567890",
  "developer_regon": "123456789",
  "developer_website": "https://example-development.pl",
  "investment_name": "Apartamenty Harmonijne",
  "investment_url": null,
  "voivodeship": "mazowieckie",
  "county": "wołomiński",
  "municipality": "Radzymin",
  "city": "Radzymin",
  "street": "ul. Słoneczna",
  "building_number": "12",
  "postal_code": "05-250",
  "property_type": "apartment",
  "property_type_raw": "Mieszkanie",
  "unit_number": "53H/2",
  "source_unit_id": "2976",
  "area_m2": 58.3,
  "rooms": 4,
  "floor": 1,
  "price_total": 558436.0,
  "price_per_m2": 9578.66,
  "price_total_with_extras": null,
  "currency": "PLN",
  "vat_rate": 8.0,
  "price_total_valid_from": "2025-09-11",
  "price_per_m2_valid_from": "2025-09-11",
  "prospectus_url": null,
  "previous_price_total": 572000.0,
  "price_change": -13564.0,
  "price_change_pct": -2.37,
  "price_changed": true,
  "is_new": false,
  "first_seen_at": "2026-10-20",
  "published_date": "2026-11-03",
  "dataset_url": "https://dane.gov.pl/pl/dataset/9580",
  "file_url": "https://api.dane.gov.pl/media/resources/20261103/....csv",
  "license": "CC0 1.0"
}
```

### Pricing

Pay per event, no subscription. The prices are on the **Pricing** tab; you are charged for two events:

| Event | When |
|---|---|
| Price-list file (`price-list-file`) | once per developer price-list file read in the run |
| Unit (`unit`) | once per unit saved to the dataset; price changes cost nothing extra |

- Units make up most of the cost of a full snapshot (about 6,500 units a day for all Poland); with **Only new
  units and price changes** a daily run pays mainly the per-file fee plus the changed units.
- **Developers** is applied before download, so it lowers both fees; voivodeship, city and property-type
  filters lower only the unit fees.
- The form starts with **Max units** = 100 for a cheap first run; raise it for a full snapshot.
- Set a maximum cost per run in Apify and the actor stops cleanly when it is reached, after delivering the units
  of the last file it charged for.

### Data, licence and privacy

The source is the official Polish open-data portal dane.gov.pl. Almost all developer datasets are published under
**CC0 1.0** (no restrictions); a few use **CC BY 4.0**, which requires naming the source: every record carries its
`license`, `dataset_url` and `file_url`. The actor never outputs the developers' phone numbers, e-mail addresses or fax
numbers. Some developers are sole traders (registered in CEiDG, not KRS): for them the developer name, NIP and
REGON identify a person, as published in the official register; use such records in line with the GDPR. Prices are asking prices as published by the developers; the actor
does not correct them, it only drops values that cannot be real (e.g. a price of 5 PLN).

### Known limits

- Voivodeship and city filters work on the units inside the files, so every file read is charged; naming the
  developers is what makes a run cheaper.
- Price changes are detected on the total price; a unit published only with a price per m² shows no change.
- Files sent as XLSX or JSON (a few percent) are skipped and counted in the run's status message.
- Developers that publish no file in the chosen period are not included; use a longer period for a full snapshot.

# Actor input Schema

## `publishedWithinDays` (type: `integer`):

Read the price-list files that developers sent to dane.gov.pl in the last N days (newest file of each developer dataset). 1 = yesterday and today; run daily for a full daily feed.

## `developers` (type: `array`):

Keep only price lists whose title contains any of these developer names (e.g. Dom Development, Murapol). Applied before download, so it also makes the run cheaper. Empty = all developers.

## `voivodeships` (type: `array`):

Keep only units of investments in these voivodeships (e.g. mazowieckie, małopolskie). Empty = all Poland. Applied after download: every file read is still charged, so for a cheaper run also name the developers.

## `cities` (type: `array`):

Keep only units of investments in these cities or municipalities (e.g. Warszawa, Kraków). Empty = all. Applied after download, like voivodeships.

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

Which units to return. Price lists also contain parking places, storage rooms and commercial units as separate lines.

## `onlyChanges` (type: `boolean`):

Return only units this actor has not returned to you before and units whose price changed since it last returned them (memory kept 90 days). Every record always carries previous_price_total and price_change.

## `maxUnits` (type: `integer`):

Stop after saving this many units. The form starts at 100 for a cheap first run; the API default is 20000.

## `maxFiles` (type: `integer`):

Read at most this many price-list files (one per developer dataset).

## Actor input object example

```json
{
  "publishedWithinDays": 1,
  "developers": [],
  "voivodeships": [],
  "cities": [],
  "propertyType": "residential",
  "onlyChanges": false,
  "maxUnits": 100,
  "maxFiles": 5000
}
```

# Actor output Schema

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

The run's units in the Store table view.

## `results` (type: `string`):

Every field of every unit record.

# 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 = {
    "maxUnits": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("delfielectronics/poland-developer-prices").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 = { "maxUnits": 100 }

# Run the Actor and wait for it to finish
run = client.actor("delfielectronics/poland-developer-prices").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 '{
  "maxUnits": 100
}' |
apify call delfielectronics/poland-developer-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delfielectronics/poland-developer-prices"
        }
    }
}
```

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/4euJtu3GrwcoD7mCd/builds/gN5Ii3I4lhHBsAB7d/openapi.json