# Boliga Scraper – Danish Real Estate Listings & Sold Prices (`haketa/boliga-scraper`) Actor

Extract active listings AND sold prices (solgte boliger) from Boliga.dk, Denmark's #1 property portal. Price, m² price, rooms, size, address, energy class, coordinates & full sale history.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## Boliga Scraper – Danish Real Estate Listings & Sold Prices (Solgte Boliger)

Extract **active property listings** *and* **historical sold prices (solgte boliger / salgspriser)** from [Boliga.dk](https://www.boliga.dk) — Denmark's largest and most-used real estate marketplace. Pull clean, structured JSON, CSV, or Excel data with prices in DKK, price per m², rooms, size, build year, energy class, addresses, coordinates, sale dates and more.

Whether you are building a property valuation model, tracking the Danish housing market, generating real-estate leads, or feeding a data product — this scraper turns Boliga into a reliable, on-demand data feed. **No code, no infrastructure, no maintenance.**

> 🇩🇰 **The only Boliga scraper that covers BOTH homes for sale *and* the full sold-price history.** Most tools only scrape active listings. Sold prices (solgte boliger) are the single most valuable dataset on Boliga — covering the entire Danish market, going back decades.

---

### ⭐ Why this Boliga scraper?

- ✅ **Sold prices (solgte boliger) included** — scrape Denmark's complete sales history with final price, sale date, sale type, price per m² and price change. Perfect for valuations, CMA and market analysis.
- ✅ **Active listings (til salg)** — every home currently on the market, with price, m² price, days-on-market and foreclosure flag.
- ✅ **Nationwide coverage** — target specific zip codes, cities or regions, or scrape all of Denmark in one run.
- ✅ **Powerful filters** — property type, price range, rooms, living area, build year, and (for sold homes) the sale year.
- ✅ **25+ structured fields** — addresses, coordinates, energy class, lot size, build year, sale type and more.
- ✅ **Reliable at scale** — automatic pagination and de-duplication across thousands of properties.
- ✅ **Any format** — export to JSON, CSV, Excel, XML, or pull via API.

---

### 📋 Table of contents

1. [What is Boliga?](#-what-is-boliga)
2. [What data can you extract?](#-what-data-can-you-extract)
3. [Use cases](#-use-cases--who-is-this-for)
4. [How to use the Boliga scraper](#-how-to-use-the-boliga-scraper)
5. [Input examples](#-input-examples)
6. [Output example](#-output-example)
7. [Output fields reference](#-output-fields-reference)
8. [Tips for best results](#-tips-for-best-results)
9. [FAQ](#-frequently-asked-questions)
10. [Integrations](#-integrations--exporting-your-data)

---

### 🏠 What is Boliga?

[Boliga](https://www.boliga.dk) is one of Denmark's largest and most popular property platforms. Danes use it to browse homes for sale and — crucially — to look up what properties **actually sold for**. Boliga aggregates the entire Danish housing market across every property type:

- 🏡 **Villa** (detached houses)
- 🏘️ **Rækkehus** (townhouses)
- 🏢 **Ejerlejlighed** (owner-occupied apartments)
- 🌲 **Fritidshus** (vacation homes)
- 🤝 **Andelsbolig** (cooperative housing)
- 🚜 **Landejendom** (country properties)
- 🌳 **Grund** (plots of land)

Because Boliga combines **current listings** with a deep archive of **final sale prices** from across Denmark, it is the single richest public source of Danish real-estate data. This scraper unlocks that data for analysis, automation and product building.

---

### 📦 What data can you extract?

This actor extracts two complementary datasets from Boliga:

#### 1. Homes for sale (til salg)
Everything currently on the market: price in DKK, price per square meter, rooms, living area, lot size, build year, energy class, days-on-market, foreclosure flag, address, city, zip code, and GPS coordinates.

#### 2. Sold prices (solgte boliger) — the money data 💰
Boliga holds the full sales history of the Danish market. For each sold property you get the **sale price**, the **sale date**, the **sale type** (regular, family, or auction), **price per m²**, the **price change**, and full property specs. This is the dataset that powers:

- Automated valuation models (AVMs)
- Comparative market analysis (CMA)
- "What did the neighbor's house sell for?" tools
- Investment and yield analysis
- Market trend dashboards

Nothing else on the market combines both in a single, easy-to-use scraper.

---

### 🎯 Use cases — who is this for?

#### 🏦 Real estate investors & analysts
Track sold prices across zip codes and cities to spot under- and over-valued areas, calculate yields, and time the market.

#### 💼 PropTech & startups
Power your app, valuation model, or comparison site with fresh Danish housing data — without building and maintaining a scraper yourself.

#### 📊 Market researchers & journalists
Analyze price trends, days-on-market, price-per-m² by region, and how sale prices evolve over time.

#### 🏘️ Real estate agencies & brokers
Benchmark listings against the competition, monitor pricing in your area, and build automated CMA reports for clients.

#### 🎯 Lead generation
Identify new listings and foreclosure properties for outreach and deal sourcing.

#### 🏦 Banks & mortgage lenders
Feed Danish sold-price data into risk and collateral valuation models.

#### 🤖 Data products & AI
Build training datasets and feeds for real-estate machine learning models, chatbots, and analytics dashboards.

---

### 🚀 How to use the Boliga scraper

You don't need any coding skills. Just configure the input and click **Start**.

1. **Choose a listing type** — *For sale* (til salg) or *Sold prices* (solgte boliger).
2. **(Optional) target an area** — enter one or more Danish zip codes (e.g. `2100,8000`). Leave empty to cover all of Denmark.
3. **(Optional) add filters** — property types, price range, rooms, living area, build year, and (for sold homes) the sale year.
4. **Set Max items** — limit how many properties to collect (recommended, especially for sold prices which can return huge volumes).
5. Click **Start** and watch the results stream into your dataset.
6. **Export** to JSON, CSV, Excel, or pull via the API.

> 💡 Sold-price searches across all of Denmark can contain hundreds of thousands of records — always set **Max items**, or narrow down by zip code and sale year.

---

### 📝 Input examples

#### Example 1 — Apartments for sale in Copenhagen
```json
{
  "listingType": "forSale",
  "zipCodes": "2100,2200,2300",
  "propertyTypes": ["3"],
  "maxItems": 200
}
````

#### Example 2 — Villas sold in Aarhus since 2022 💰

```json
{
  "listingType": "sold",
  "zipCodes": "8000,8200,8210",
  "propertyTypes": ["1"],
  "soldYearMin": 2022,
  "maxItems": 500
}
```

#### Example 3 — All homes for sale under 3,000,000 DKK nationwide

```json
{
  "listingType": "forSale",
  "priceMax": 3000000,
  "maxItems": 1000
}
```

#### Example 4 — Sold properties via a ready-made Boliga URL

```json
{
  "startUrls": [
    { "url": "https://api.boliga.dk/api/v2/sold/search/results?zipCodes=2100&propertyType=3" }
  ],
  "maxItems": 300
}
```

***

### 📤 Output example

Each property is saved as a clean JSON record. Example of a **sold** apartment:

```json
{
  "listingType": "sold",
  "id": "1234567",
  "url": "https://www.boliga.dk/bolig/1234567",
  "propertyType": "Ejerlejlighed",
  "propertyTypeCode": 3,
  "address": "Østerbrogade 100, 2. tv",
  "zipCode": "2100",
  "city": "København Ø",
  "price": 4250000,
  "squareMeterPrice": 58219,
  "priceChangePercent": -3.5,
  "rooms": 3,
  "size": 73,
  "lotSize": null,
  "buildYear": 1932,
  "energyClass": "C",
  "soldDate": "2026-04-18",
  "salesType": "Almindelig handel",
  "latitude": 55.7095,
  "longitude": 12.5780,
  "scrapedAt": "2026-06-03T10:00:00.000Z"
}
```

And an **active** listing:

```json
{
  "listingType": "forSale",
  "id": "7654321",
  "url": "https://www.boliga.dk/bolig/7654321",
  "propertyType": "Villa",
  "propertyTypeCode": 1,
  "address": "Skovvej 12",
  "zipCode": "8000",
  "city": "Aarhus C",
  "price": 5495000,
  "squareMeterPrice": 32134,
  "rooms": 5,
  "size": 171,
  "lotSize": 642,
  "buildYear": 1968,
  "energyClass": "D",
  "daysForSale": 23,
  "isForeclosure": false,
  "latitude": 56.1572,
  "longitude": 10.2107,
  "scrapedAt": "2026-06-03T10:00:00.000Z"
}
```

***

### 📚 Output fields reference

| Field | Description |
|---|---|
| `listingType` | `forSale` or `sold` |
| `id` | Boliga property ID |
| `url` | Direct link to the property page |
| `propertyType` | Villa, apartment, townhouse, etc. |
| `propertyTypeCode` | Numeric Boliga property-type code |
| `address` | Street address |
| `zipCode` | Postal code |
| `city` | City / town |
| `municipality` | Municipality |
| `price` | Price in DKK (sale price for sold homes) |
| `squareMeterPrice` | Price per square meter (DKK/m²) |
| `priceChangePercent` | Price change in % |
| `rooms` | Number of rooms |
| `size` | Living area in m² |
| `lotSize` | Lot / land area in m² |
| `floor` | Floor |
| `buildYear` | Year built |
| `energyClass` | Energy label (A–G) |
| `basementSize` | Basement area in m² |
| `daysForSale` | Days on market (active listings) |
| `isForeclosure` | Foreclosure flag (active listings) |
| `soldDate` | Date the property was sold |
| `salesType` | Regular, family or auction sale |
| `latitude` / `longitude` | GPS coordinates |
| `scrapedAt` | When the record was collected (ISO 8601) |

***

### 💡 Tips for best results

- 📍 **Narrow with zip codes.** Targeting `2100,8000` returns exactly the areas you care about and runs much faster than scraping all of Denmark.
- 💰 **For valuations, use `sold` + a recent `soldYearMin`.** Recent comparable sales are the gold standard for estimating value.
- 🔢 **Always set Max items for sold searches.** Denmark's sold-price archive is enormous; a nationwide sold search without a limit can run for a very long time.
- 🎯 **Combine filters** (price + rooms + size + build year) to zero in on exactly the segment you care about.
- 🏷️ **Property type codes:** 1 = Villa, 2 = Rækkehus, 3 = Ejerlejlighed, 4 = Fritidshus, 5 = Andelsbolig, 6 = Landejendom, 7 = Helårsgrund, 8 = Fritidsgrund, 9 = Villalejlighed.

***

### ❓ Frequently asked questions

#### Does this scraper get sold prices (solgte boliger)?

**Yes** — and that's its biggest advantage. Set `listingType` to `sold` to scrape Boliga's full archive of Danish sale prices, including the sale date, sale type and price change. Most other Boliga scrapers only cover active listings.

#### Can I scrape the whole of Denmark?

Yes. Leave the zip codes field empty to cover the entire country. For sold prices this can be a very large dataset, so set **Max items** or filter by zip code and sale year.

#### What's the difference between the sale types?

**Almindelig handel** is a regular open-market sale, **Familiehandel** is a sale between family members (often below market value), and **Auktion** is a forced/auction sale. The `salesType` field tells you which one each record is — important when using sold prices for valuation.

#### How many properties can I scrape?

As many as you need. Use **Max items** to cap a run, and split very large areas by zip code to keep runs fast and focused.

#### What formats can I export to?

JSON, CSV, Excel, XML, RSS, or programmatically via the Apify API. The data also includes a clean tabular **overview** view in the dataset.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run the scraper daily or weekly and keep your dataset fresh — great for monitoring new listings or tracking sold prices over time.

#### Can I get notified of new listings?

Combine scheduled runs with Apify integrations (webhooks, Make, Zapier, Slack, email) to get alerts whenever new properties match your criteria.

***

### 🔌 Integrations & exporting your data

This actor works seamlessly with the Apify ecosystem:

- **API** — pull results programmatically with a single HTTP request.
- **Webhooks** — trigger downstream workflows when a run finishes.
- **Make / Zapier** — connect Boliga data to thousands of apps with no code.
- **Google Sheets, Slack, email** — push results where your team works.
- **Schedules** — automate recurring runs to keep data fresh.

Results can be downloaded as JSON, CSV, Excel, XML, or RSS at any time.

***

### 🆘 Support

Found a bug or need a new field or filter? Open an issue on the actor's **Issues** tab. Feedback and feature requests are welcome — this scraper is actively maintained.

**Happy scraping! 🏠🇩🇰**

# Actor input Schema

## `listingType` (type: `string`):

Scrape homes currently FOR SALE (til salg), or historical SOLD prices (solgte boliger / salgspriser).

## `zipCodes` (type: `string`):

Comma-separated Danish postal codes to target, e.g. "2100,2200,8000" (Copenhagen Ø, Copenhagen N, Aarhus C). Leave empty to scrape all of Denmark.

## `propertyTypes` (type: `array`):

Which dwelling types to include. Empty = all types.

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

Minimum price in Danish kroner.

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

Maximum price in Danish kroner.

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

Minimum number of rooms.

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

Maximum number of rooms.

## `sizeMin` (type: `integer`):

Minimum living area in square meters.

## `sizeMax` (type: `integer`):

Maximum living area in square meters.

## `buildYearMin` (type: `integer`):

Earliest construction year.

## `buildYearMax` (type: `integer`):

Latest construction year.

## `soldYearMin` (type: `integer`):

Only include homes sold in or after this year. Ignored for homes for sale.

## `soldYearMax` (type: `integer`):

Only include homes sold in or before this year. Ignored for homes for sale.

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

Optional. Paste ready-made Boliga API URLs (https://api.boliga.dk/api/v2/search/results?... or .../sold/search/results?...). When provided, these take priority and the filters above are ignored.

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

Stop after collecting this many properties (0 = no limit). Sold searches can return hundreds of thousands of records, so set a limit unless you really want everything.

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

Recommended. Boliga rate-limits direct traffic; a Danish (DK) residential proxy gives the most reliable results.

## Actor input object example

```json
{
  "listingType": "forSale",
  "zipCodes": "2100,8000",
  "propertyTypes": [],
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DK"
  }
}
```

# Actor output Schema

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

Active listings and sold prices collected from Boliga.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DK"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/boliga-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DK",
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boliga Scraper – Danish Real Estate Listings & Sold Prices",
        "description": "Extract active listings AND sold prices (solgte boliger) from Boliga.dk, Denmark's #1 property portal. Price, m² price, rooms, size, address, energy class, coordinates & full sale history.",
        "version": "0.1",
        "x-build-id": "v2i6cA29Shk1IT4Nu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~boliga-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-boliga-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/haketa~boliga-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-boliga-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/haketa~boliga-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-boliga-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": {
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "forSale",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Scrape homes currently FOR SALE (til salg), or historical SOLD prices (solgte boliger / salgspriser).",
                        "default": "forSale"
                    },
                    "zipCodes": {
                        "title": "Zip codes",
                        "type": "string",
                        "description": "Comma-separated Danish postal codes to target, e.g. \"2100,2200,8000\" (Copenhagen Ø, Copenhagen N, Aarhus C). Leave empty to scrape all of Denmark."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Which dwelling types to include. Empty = all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6",
                                "7",
                                "8",
                                "9"
                            ],
                            "enumTitles": [
                                "Villa",
                                "Townhouse (rækkehus)",
                                "Apartment (ejerlejlighed)",
                                "Vacation home (fritidshus)",
                                "Cooperative (andelsbolig)",
                                "Country property (landejendom)",
                                "Plot, year-round (helårsgrund)",
                                "Plot, vacation (fritidsgrund)",
                                "Villa apartment (villalejlighed)"
                            ]
                        },
                        "default": []
                    },
                    "priceMin": {
                        "title": "Min price (DKK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Danish kroner."
                    },
                    "priceMax": {
                        "title": "Max price (DKK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Danish kroner."
                    },
                    "roomsMin": {
                        "title": "Min rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of rooms."
                    },
                    "roomsMax": {
                        "title": "Max rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rooms."
                    },
                    "sizeMin": {
                        "title": "Min living area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living area in square meters."
                    },
                    "sizeMax": {
                        "title": "Max living area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living area in square meters."
                    },
                    "buildYearMin": {
                        "title": "Min build year",
                        "type": "integer",
                        "description": "Earliest construction year."
                    },
                    "buildYearMax": {
                        "title": "Max build year",
                        "type": "integer",
                        "description": "Latest construction year."
                    },
                    "soldYearMin": {
                        "title": "Sold from year (only for Sold prices)",
                        "type": "integer",
                        "description": "Only include homes sold in or after this year. Ignored for homes for sale."
                    },
                    "soldYearMax": {
                        "title": "Sold to year (only for Sold prices)",
                        "type": "integer",
                        "description": "Only include homes sold in or before this year. Ignored for homes for sale."
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Optional. Paste ready-made Boliga API URLs (https://api.boliga.dk/api/v2/search/results?... or .../sold/search/results?...). When provided, these take priority and the filters above are ignored.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many properties (0 = no limit). Sold searches can return hundreds of thousands of records, so set a limit unless you really want everything.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Recommended. Boliga rate-limits direct traffic; a Danish (DK) residential proxy gives the most reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "DK"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
