# Boliga Denmark Real Estate Scraper (`parsebird/boliga-scraper`) Actor

Scrape Boliga.dk homes for sale and sold prices across Denmark: price, m² price, address, rooms, size, build year, energy label, days on market, sale date, GPS. Filter by postal code, property type, price and size.

- **URL**: https://apify.com/parsebird/boliga-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.59 / 1,000 properties

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

### Boliga Denmark Real Estate Scraper

**Boliga Denmark Real Estate Scraper** extracts homes for sale and historical sold prices from [Boliga.dk](https://www.boliga.dk), Denmark's property portal that collects every home publicly offered for sale through Danish estate agents and Boliga Selvsalg. Pick a city or postal code and get the price, price per m², address, rooms, living area, lot size, build year, energy label, days on market, sale date and GPS position of every property, as clean JSON, CSV or Excel.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search all of Denmark or any city, Copenhagen district or postal code for homes til salg or solgte boliger back to 1992, filter by property type, price, rooms, size, build year, sold year and sales type, and add estate agent contacts when you need them.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/boliga-scraper. Scrapes Danish real estate from Boliga.dk: homes for sale (til salg) and historical sold prices (solgte boliger / salgspriser). Call via ApifyClient: client.actor("parsebird/boliga-scraper").call(run_input={"listingType": "sold", "zipCodes": "8000,8200", "propertyTypes": ["1"], "soldYearMin": 2022, "maxItems": 500}). Inputs: listingType ("forSale" or "sold", default "forSale"), zipAreas (array of area keys, e.g. "copenhagen", "koebenhavn-oe", "frederiksberg", "aarhus", "odense", "aalborg", "esbjerg", "north-zealand", "bornholm", "funen", "north-jutland"; empty = all of Denmark), zipCodes (string, comma-separated 4-digit Danish postal codes, combined with zipAreas), propertyTypes (array of codes: "1" Villa, "2" Rækkehus/townhouse, "3" Ejerlejlighed/apartment, "4" Fritidshus/holiday home, "5" Andelsbolig/co-op, "6" Landejendom/farm, "7" Helårsgrund/residential plot, "8" Fritidsgrund/holiday plot, "9" Villalejlighed; sold prices cover 1, 2, 3, 4, 6), priceMin / priceMax (integer DKK), roomsMin / roomsMax, sizeMin / sizeMax (m²), buildYearMin / buildYearMax, soldYearMin / soldYearMax (sold only), salesTypes (sold only: "regular", "family", "auction", "other"), includeDetails (boolean, for sale only: adds agent name, phone, email, website and all photo URLs), startUrls (array of Boliga API URLs https://api.boliga.dk/api/v2/search/results?... or .../sold/search/results?...; overrides filters), maxItems (integer, default 0 = no limit), proxyConfiguration (optional). Output: listingType, id, url, propertyType, propertyTypeEnglish, propertyTypeCode, address, zipCode, city, municipality, municipalityCode, price, squareMeterPrice, priceChangePercent, rooms, size, lotSize, basementSize, floor, buildYear, energyClass, monthlyOwnerCost, downPayment, daysForSale, listedAt, isForeclosure, isSelfSale, views, soldDate, salesType, latitude, longitude, imageUrl, addressUrl, ouId, bfeNumber, scrapedAt (+ agentName, agentPhone, agentEmail, agentWebsite, agentListingUrl, imageUrls with includeDetails). Pricing: pay per property saved. Full API spec: https://apify.com/parsebird/boliga-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```

### What is Boliga Denmark Real Estate Scraper?

**Boliga Denmark Real Estate Scraper** turns [Boliga.dk](https://www.boliga.dk) into a structured dataset. Choose **homes for sale** or **sold prices**, pick an area, set your filters and click Start. The scraper collects every matching property with prices, sizes, location and dates.

It works as a **Boliga API alternative**: no account, no API key and no browser needed. Use it to scrape Boliga for current listings or to pull Danish house price history (salgspriser) by postal code, property type and year.

### What can Boliga Denmark Real Estate Scraper do?

- 🏠 **Homes for sale (til salg).** Villas, townhouses, apartments, holiday homes, co-ops, farms, plots and villa apartments currently listed on Boliga.dk, with asking price, price change, days on market, monthly owner cost and down payment.
- 💰 **Sold prices (solgte boliger).** Historical sales back to 1992 with sale price, sale date, price per m², the change from asking price, and the sales type: regular, family, auction or other.
- 🗺️ **Any part of Denmark.** All of Denmark, 34 cities and Copenhagen districts, 9 regions by postal code band, or your own list of postal codes (postnumre).
- 🔎 **Boliga's own filters.** Property type, price, rooms, living area, build year, sold year and sales type are sent to Boliga's search, so you only collect matching properties.
- 📇 **Estate agent contacts.** Turn on **Add agent contact & all photos** to add the agent's name, phone, email and website plus every photo of each listing.
- 🔗 **Start URLs.** Paste Boliga API search URLs to reuse an exact search.
- 📅 **Scheduling and monitoring.** Run daily or weekly with [Apify Schedules](https://docs.apify.com/platform/schedules) to track new listings, price drops and recent sales.
- 🔌 **API and integrations.** Use the [Apify API](https://docs.apify.com/api/v2), or send results to Google Sheets, Zapier, Make, Slack or webhooks with [Apify integrations](https://docs.apify.com/platform/integrations). Export as JSON, CSV, Excel, XML or HTML.

### What data can you extract from Boliga.dk?

| Field | Description |
|-------|-------------|
| `listingType` | `forSale` or `sold` |
| `id` / `url` | Boliga listing ID and link to the property page on Boliga.dk |
| `propertyType` / `propertyTypeEnglish` / `propertyTypeCode` | Boliga's type ("Villa", "Ejerlejlighed"…), an English name and the numeric code |
| `address` / `zipCode` / `city` | Street address with floor and door, postal code and city |
| `municipality` / `municipalityCode` | Municipality (kommune) name and code, e.g. "København" / 101 |
| `price` / `squareMeterPrice` | Asking price or sale price in DKK, and DKK per m² |
| `priceChangePercent` | For sale: total change from the first asking price. Sold: sale price vs. last asking price |
| `rooms` / `size` / `lotSize` / `basementSize` / `floor` | Rooms, living area, lot area and basement area in m², floor |
| `buildYear` / `energyClass` | Construction year and energy label as Boliga stores it: A–G, plus Boliga's own letter codes (such as I, J, K) on some newer homes |
| `monthlyOwnerCost` / `downPayment` | Monthly owner cost (ejerudgift) and down payment (udbetaling) in DKK, for sale only |
| `daysForSale` / `listedAt` / `views` | Days on market, listing date and page views on Boliga, for sale only |
| `isForeclosure` / `isSelfSale` | Foreclosure (tvangsauktion) and Boliga Selvsalg flags, for sale only |
| `soldDate` / `salesType` | Sale date and sales type ("Alm. Salg", "Fam. Salg", "Auktion", "Andet"), sold only |
| `latitude` / `longitude` | GPS coordinates |
| `imageUrl` / `addressUrl` | Main photo and the Boliga address page with the property's sales history |
| `ouId` / `bfeNumber` | Boliga address ID and the BFE number from the Danish property register |
| `agentName` / `agentPhone` / `agentEmail` / `agentWebsite` / `imageUrls` | Estate agent contact and all photos (with **Add agent contact & all photos**) |

### How to scrape Boliga.dk

1. Open [Boliga Denmark Real Estate Scraper](https://apify.com/parsebird/boliga-scraper) on Apify Store and click **Try for free**.
2. Choose **Homes for sale** or **Sold prices**.
3. Pick one or more **Areas / cities**, or type postal codes like `2100,2200` into **More postal codes**. Leave both empty for all of Denmark.
4. Pick **Property types** and set price, rooms, living area and build year filters. For sold prices, set **Sold from year** and **Sold until year**.
5. Set **Max properties**, or 0 for everything.
6. Click **Start**, then download the results as JSON, CSV, Excel, XML or HTML from the **Output** tab, or read them with the API.

### How much does it cost to scrape Boliga.dk?

Boliga Denmark Real Estate Scraper uses **pay-per-event** pricing: you pay for each property saved. Compute and proxy costs are included in the price.

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| `result` (per property) | $0.00299 | $0.00249 | $0.00199 | $0.00159 |
| Per 1,000 properties | **$2.99** | **$2.49** | **$1.99** | **$1.59** |

For example, 1,000 sold prices from Aarhus cost $2.99 on the Free plan. Turning on agent contacts doesn't change the price. You can set a maximum cost per run in Apify Console, and the Actor stops when it's reached.

### Input

Fill in the form on the [Input tab](https://apify.com/parsebird/boliga-scraper/input-schema) or pass JSON through the API.

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `listingType` | string | No | `forSale` | `forSale` (til salg) or `sold` (solgte boliger) |
| `zipAreas` | array | No | `[]` | Areas such as `copenhagen`, `koebenhavn-oe`, `frederiksberg`, `aarhus`, `odense`, `aalborg`, `north-zealand`, `bornholm`. Empty = all of Denmark |
| `zipCodes` | string | No | — | Extra postal codes, comma-separated, e.g. `2100,8000` |
| `propertyTypes` | array | No | `[]` | `1` Villa, `2` Rækkehus, `3` Ejerlejlighed, `4` Fritidshus, `5` Andelsbolig, `6` Landejendom, `7` Helårsgrund, `8` Fritidsgrund, `9` Villalejlighed. Empty = all |
| `priceMin` / `priceMax` | integer | No | — | Price range in DKK |
| `roomsMin` / `roomsMax` | integer | No | — | Number of rooms |
| `sizeMin` / `sizeMax` | integer | No | — | Living area in m² |
| `buildYearMin` / `buildYearMax` | integer | No | — | Construction year range |
| `soldYearMin` / `soldYearMax` | integer | No | — | Sold prices only: year of sale |
| `salesTypes` | array | No | `[]` | Sold prices only: `regular`, `family`, `auction`, `other` |
| `includeDetails` | boolean | No | `false` | Homes for sale only: add agent contact and all photo URLs |
| `startUrls` | array | No | `[]` | Boliga API search URLs; the filters are ignored when set |
| `maxItems` | integer | No | `0` | Maximum properties to save; 0 = no limit |
| `proxyConfiguration` | object | No | direct | Optional proxy settings |

**Example: apartments for sale in Copenhagen Ø, N and S**

```json
{
    "listingType": "forSale",
    "zipCodes": "2100,2200,2300",
    "propertyTypes": ["3"],
    "maxItems": 200
}
```

**Example: villas sold in Aarhus since 2022**

```json
{
    "listingType": "sold",
    "zipAreas": ["aarhus"],
    "propertyTypes": ["1"],
    "soldYearMin": 2022,
    "maxItems": 500
}
```

**Example: all homes for sale under 3,000,000 DKK nationwide**

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

**Example: sold apartments from a Boliga API URL**

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

### Output example

A home for sale:

```json
{
    "listingType": "forSale",
    "id": "2372131",
    "url": "https://www.boliga.dk/bolig/2372131",
    "propertyType": "Ejerlejlighed",
    "propertyTypeEnglish": "Apartment (owner-occupied)",
    "propertyTypeCode": 3,
    "secondaryPropertyType": null,
    "address": "Drejøgade 26E, 2. 202.",
    "zipCode": "2100",
    "city": "København Ø",
    "municipality": "København",
    "municipalityCode": 101,
    "price": 3100000,
    "squareMeterPrice": 79487,
    "priceChangePercent": -6,
    "rooms": 1,
    "size": 39,
    "lotSize": null,
    "basementSize": null,
    "floor": 2,
    "buildYear": 1974,
    "energyClass": "C",
    "monthlyOwnerCost": 2868,
    "downPayment": 155000,
    "daysForSale": 21,
    "listedAt": "2026-09-29T14:35:35.533Z",
    "isForeclosure": false,
    "isSelfSale": false,
    "openHouse": null,
    "views": 144,
    "soldDate": null,
    "salesType": null,
    "latitude": 55.71149,
    "longitude": 12.57206,
    "imageUrl": "https://i.boliga.org/dk/550x/2372/2372131.jpg",
    "addressUrl": "https://www.boliga.dk/adresse/drejoegade-26e-2-202-2100-koebenhavn-oe-1252221602",
    "ouId": 1252221602,
    "bfeNumber": 144014,
    "scrapedAt": "2026-10-20T13:51:16.602Z"
}
```

A sold property:

```json
{
    "listingType": "sold",
    "id": "2358261",
    "url": "https://www.boliga.dk/adresse/hjoerringgade-5-st-tv-2100-koebenhavn-oe-1131519103",
    "listingUrl": "https://www.boliga.dk/bolig/2358261",
    "propertyType": "Ejerlejlighed",
    "propertyTypeEnglish": "Apartment (owner-occupied)",
    "propertyTypeCode": 3,
    "address": "Hjørringgade 5, st. tv",
    "zipCode": "2100",
    "city": "København Ø",
    "municipality": "København",
    "municipalityCode": 101,
    "price": 5550000,
    "squareMeterPrice": 75000,
    "priceChangePercent": -2.63,
    "rooms": 3,
    "size": 74,
    "buildYear": 1901,
    "soldDate": "2026-10-14",
    "salesType": "Alm. Salg",
    "latitude": 55.706127,
    "longitude": 12.587321,
    "ouId": 1131519103,
    "propertyGuid": "B14485A0-EAE5-4AD3-9030-DF90B0247A6E",
    "bfeNumber": 147847,
    "scrapedAt": "2026-10-20T13:55:02.114Z"
}
```

### Use the Boliga scraper API

Call the Actor from your own code with the [Apify API client](https://docs.apify.com/api/client/python). Find your token in [Apify Console → Settings → Integrations](https://console.apify.com/settings/integrations).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/boliga-scraper").call(run_input={
    "listingType": "sold",
    "zipAreas": ["odense"],
    "propertyTypes": ["1", "2"],
    "soldYearMin": 2024,
    "maxItems": 1000,
})

for sale in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(sale["soldDate"], sale["address"], sale["price"], sale["squareMeterPrice"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/boliga-scraper').call({
    listingType: 'forSale',
    zipAreas: ['copenhagen'],
    propertyTypes: ['3'],
    priceMax: 4000000,
    includeDetails: true,
    maxItems: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((home) => console.log(home.price, home.address, home.agentName, home.agentPhone));
```

You can also start runs over plain HTTP from the [API tab](https://apify.com/parsebird/boliga-scraper/api), or connect the Actor to AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Use cases

- **Danish house price analysis.** Pull sold prices by postal code, property type and year to track price per m² over time.
- **Property valuation.** Compare a home with recent sales of similar size and build year on the same street or postal code.
- **New listing and price drop alerts.** Schedule a daily run and push new listings or `priceChangePercent` drops to Slack or Google Sheets.
- **Real estate investing.** Find foreclosures, long-listed homes (`daysForSale`) or cheap holiday homes and plots.
- **Lead generation for agents and service providers.** Collect listings with estate agent contacts by area.
- **Research and journalism.** Build datasets of the Danish housing market for reports and maps, using GPS coordinates and municipality codes.

### How it works

1. Your filters go straight to Boliga's search for homes for sale or for sold prices. Areas become postal code ranges; sold-price searches run one postal code, range or sales type at a time because that's how Boliga's sold search works.
2. Properties are loaded 500 at a time, newest first for sold prices, until your limit or the end of the results.
3. With agent contacts turned on, each listing's detail page is loaded too.
4. A property that shows up twice is saved once. If Apify restarts the run on another server, it continues where it left off.

### FAQ

**Do I need a Boliga account?**
No. The Actor reads the same public listings and sold prices that anyone can see on Boliga.dk.

**How far back do sold prices go?**
Boliga's sold-price records go back to 1992. Use **Sold from year** and **Sold until year** to pick a period.

**Why can't I get sold prices for co-ops or plots?**
Boliga's sold-price records cover villas, townhouses, apartments, holiday homes and farms only. Andelsboliger, plots and villa apartments are available as homes for sale; for sold prices the Actor skips those types and tells you in the log.

**Why does a search for holiday homes include apartments?**
Boliga files some listings under two types, for example a holiday apartment as both Ejerlejlighed and Fritidshus. Its search matches either type, so the record keeps Boliga's main type in `propertyType` and the second one in `secondaryPropertyType`.

**Why do some energy labels show I, J or K?**
That's how Boliga stores the label for those listings. The Actor passes it on unchanged so you can map it yourself; open the listing on Boliga.dk to see the label as displayed.

**Some sold records have no `id`. Why?**
Many sales, especially family sales and older ones, were never listed on Boliga. They still have the address page link in `url`, the address ID `ouId` and the BFE number.

**Which URLs can I paste into Start URLs?**
Boliga API search URLs, either `https://api.boliga.dk/api/v2/search/results?...` for homes for sale or `https://api.boliga.dk/api/v2/sold/search/results?...` for sold prices, with Boliga's own parameters such as `zipCodes`, `zipcodeFrom`, `zipcodeTo`, `propertyType`, `priceMax` or `salesDateMin`.

**Do I need a proxy?**
No. The Actor connects directly and switches to [Apify Proxy](https://docs.apify.com/platform/proxy) on its own if Boliga starts refusing requests. Any proxy cost is included in the result price.

**Can I schedule runs or export to Google Sheets?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) for recurring runs and [integrations](https://docs.apify.com/platform/integrations) for Google Sheets, Zapier, Make, Slack and webhooks.

**Something is missing or broken?**
Open an issue on the [Issues tab](https://apify.com/parsebird/boliga-scraper/issues). Feedback and feature requests are welcome there too.

### Is it legal to scrape Boliga.dk?

The Actor collects only public listings and sold prices that Boliga.dk shows to every visitor. It doesn't log in or access account data. Estate agent names, phone numbers and emails can be personal data under the EU's GDPR, so make sure you have a lawful basis to store and contact them. Read more in Apify's blog post [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other real estate scrapers

| Actor | What it does |
|-------|--------------|
| [Funda.nl Scraper](https://apify.com/parsebird/funda-scraper) | Scrape Dutch homes for sale and rent from Funda |
| [ImmoScout24 Scraper](https://apify.com/parsebird/immoscout24-scraper) | Scrape German property listings from ImmoScout24 |
| [Immobiliare.it Scraper](https://apify.com/parsebird/immobiliare-it-scraper) | Scrape Italian property listings from Immobiliare.it |
| [Sreality.cz Scraper](https://apify.com/parsebird/sreality-cz-scraper) | Scrape Czech property listings from Sreality.cz |
| [Leboncoin Real Estate Scraper](https://apify.com/parsebird/leboncoin-real-estate-scraper) | Scrape French property listings from Leboncoin |
| [Realtor.com Scraper](https://apify.com/parsebird/realtor-scraper) | Scrape US homes for sale, rent and sold from Realtor.com |

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/boliga-scraper/changelog.md

# Actor input Schema

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

Choose homes currently <b>for sale</b> (til salg) or historical <b>sold prices</b> (solgte boliger / salgspriser, back to 1992).

## `zipAreas` (type: `array`):

Pick one or more Danish cities, Copenhagen districts or regions. Leave empty to search all of Denmark. Need a postal code that isn't listed? Add it under <b>More postal codes</b>.

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

Add Danish postal codes (postnumre), comma-separated, e.g. <code>2100,2200,8000</code>. Combined with the areas above.

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

Pick the home types to include. Leave empty for all types.

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

Stop after saving this many properties. <b>0 = no limit.</b> Sold searches can return hundreds of thousands of records, so set a limit unless you want them all.

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

Minimum asking price (for sale) or sale price (sold), in Danish kroner.

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

Maximum asking price (for sale) or sale price (sold), in Danish kroner.

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

Minimum number of rooms (værelser).

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

Maximum number of rooms (værelser).

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

Minimum living area (boligareal) in square meters.

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

Maximum living area (boligareal) in square meters.

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

Earliest construction year, e.g. 1960.

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

Latest construction year, e.g. 2020.

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

Only sold properties: keep homes sold in or after this year, e.g. 2022.

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

Only sold properties: keep homes sold in or before this year.

## `salesTypes` (type: `array`):

Only sold properties: pick the kinds of sale to include. Leave empty for all.

## `includeDetails` (type: `boolean`):

Only homes for sale: also load each listing's detail page to add the estate agent's name, phone, email and website, the agent's own listing link and every photo URL. Slower (one extra request per listing).

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

Paste ready-made Boliga API search URLs, e.g. <code>https://api.boliga.dk/api/v2/search/results?zipCodes=2100\&propertyType=3</code> or <code>https://api.boliga.dk/api/v2/sold/search/results?zipcodeFrom=2100\&zipcodeTo=2100</code>. When you add start URLs, the search fields above are ignored.

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

Optional. The actor connects directly by default and switches to Apify Proxy on its own if Boliga starts refusing requests.

## Actor input object example

```json
{
  "listingType": "forSale",
  "zipAreas": [],
  "zipCodes": "2100",
  "propertyTypes": [],
  "maxItems": 50,
  "salesTypes": [],
  "includeDetails": false,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "listingType": "forSale",
    "zipCodes": "2100",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "listingType": "forSale",
    "zipCodes": "2100",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/boliga-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 '{
  "listingType": "forSale",
  "zipCodes": "2100",
  "maxItems": 50
}' |
apify call parsebird/boliga-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/boliga-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/z3B7wbNqsseOg69QY/builds/CMdzNIuSmPYexHU6q/openapi.json
