# Boligsiden.dk Real Estate Scraper (`scrapeworks/boligsiden-real-estate-scraper`) Actor

Scrape Danish property listings from Boligsiden.dk in bulk: villas, condos, townhouses and holiday homes. Get asking price, price per m2, rooms, area, year built, energy label, address, geo, public valuation, realtor contact and sale history. No login.

- **URL**: https://apify.com/scrapeworks/boligsiden-real-estate-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Real estate, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Boligsiden.dk Real Estate Scraper

**Scrape Danish property listings from [Boligsiden.dk](https://www.boligsiden.dk) in bulk.** Pull villas, condos (ejerlejligheder), townhouses, holiday homes, cooperatives and more — with asking price, price per m², rooms, living and lot area, year built, energy label, full address + GPS coordinates, monthly expense, public valuation, mortgage figures, realtor contact details, photos, and the complete public **sale-price history** for every address.

No login, no API key, no browser. The actor reads Boligsiden's own public JSON API and paginates deep, so a single run returns thousands of clean, structured rows ready for a spreadsheet, database or model.

---

### What you get

One row per listing, with these fields:

| Field | Description |
|---|---|
| `caseID` | Boligsiden's unique listing id |
| `addressType` | villa, condo, terraced house, holiday house, cooperative, … |
| `status` | Listing status (e.g. `open`) |
| `boligsidenUrl` | Direct link to the listing on Boligsiden.dk |
| `realtorListingUrl` | Link to the listing on the realtor's own site |
| `roadName`, `houseNumber`, `floor`, `door` | Street address parts |
| `zipCode`, `city`, `placeName` | Postal code, city, local place name |
| `municipality`, `municipalityCode`, `municipalitySlug` | Danish municipality (kommune) |
| `province`, `regionCode` | Region / province |
| `latitude`, `longitude` | GPS coordinates |
| `priceCash` | Asking price in DKK |
| `perAreaPrice` | Price per m² in DKK |
| `priceChangePercentage` | % change from the original asking price |
| `monthlyExpense` | Owner's monthly expense (ejerudgift) in DKK |
| `latestValuation` | Latest public valuation (offentlig vurdering) in DKK |
| `downPayment`, `grossMortgage`, `netMortgage` | Financing figures in DKK |
| `housingArea`, `weightedArea`, `lotArea` | Living area, weighted area, plot size (m²) |
| `numberOfRooms`, `numberOfFloors`, `numberOfBathrooms`, `numberOfToilets` | Room counts |
| `yearBuilt` | Construction year |
| `energyLabel` | Energy label (e.g. `a2010`, `b`, `c`) |
| `hasBalcony`, `hasElevator`, `hasTerrace` | Amenity flags |
| `daysListed`, `daysOnMarketTotal` | Days on market |
| `descriptionTitle`, `descriptionBody` | Listing headline and full description text |
| `realtorName`, `realtorPhone`, `realtorEmail`, `realtorCvr` | Realtor contact + CVR (company) number |
| `realtorRoadName`, `realtorHouseNumber`, `realtorZipCode`, `realtorCity` | Realtor office address |
| `defaultImage`, `images`, `imageCount` | Main photo + full gallery (high-res URLs) |
| `saleHistory` | Every past registered sale for the address: `date`, `amount`, `perAreaPrice`, `type` |
| `searchAddressTypes`, `searchLocation`, `scrapedAt` | Provenance for each row |

---

### Input

Everything is optional — with no input at all, the actor scrapes the whole for-sale market (up to 10,000 listings).

- **Property types** (`addressTypes`) — which types to include. Leave empty for **all** types. Valid values: `villa`, `condo`, `terraced house`, `holiday house`, `cooperative`, `villa apartment`, `double house`, `multiple family house`, `farm`, `hobby farm`, `cattle farm`, `pig farm`, `plant farm`, `forest`, `allotment`, `full year plot`, `holiday plot`, `houseboat`, `garage`, `parking`, `business`, `room`.
- **Municipalities** (`municipalities`) — a list of Danish municipality slugs (e.g. `koebenhavn`, `aarhus`, `odense`, `aalborg`, `gentofte`, `faxe`). **This is the bulk axis** — one deep search runs per municipality and the results are merged and de-duplicated, so a list of municipalities pulls far past the 10,000-per-search limit.
- **ZIP codes** (`zipCodes`) — a list of postal codes (e.g. `2100`, `8000`, `5000`). Used when no municipalities are given.
- **Min / max price** (`priceMin`, `priceMax`) — asking price bounds in DKK.
- **Min / max living area** (`areaMin`, `areaMax`) — housing area bounds in m².
- **Max results per search** (`maxResultsPerSearch`) — cap per municipality / ZIP / all-Denmark search (up to 10,000).
- **Max results overall** (`maxResults`) — optional total cap across all searches.

#### Example input

```json
{
  "addressTypes": ["villa", "condo", "terraced house"],
  "municipalities": ["koebenhavn", "aarhus", "odense", "aalborg"],
  "priceMin": 1000000,
  "maxResultsPerSearch": 5000
}
````

***

### Output sample

```json
{
  "caseID": "99110557-47cf-459b-badb-522cf04f114f",
  "addressType": "villa",
  "status": "open",
  "boligsidenUrl": "https://www.boligsiden.dk/adresse/aavaenget-9-4690-haslev-03201285___9_______",
  "realtorListingUrl": "https://www.edc.dk/sag/?sagsnr=48007976",
  "roadName": "Åvænget",
  "houseNumber": "9",
  "zipCode": 4690,
  "city": "Haslev",
  "placeName": "Dalby",
  "municipality": "Faxe",
  "province": "Vest- og Sydsjælland",
  "latitude": 55.309086,
  "longitude": 12.054049,
  "priceCash": 3345000,
  "perAreaPrice": 16625,
  "monthlyExpense": 3359,
  "latestValuation": 1300000,
  "downPayment": 170000,
  "grossMortgage": 17917,
  "netMortgage": 14313,
  "housingArea": 190,
  "lotArea": 1012,
  "numberOfRooms": 5,
  "numberOfBathrooms": 1,
  "yearBuilt": 1975,
  "energyLabel": "a2010",
  "daysListed": 40,
  "descriptionTitle": "nydeligt renoveret étplansvilla",
  "realtorName": "EDC Selandia Haslev",
  "realtorPhone": "56313300",
  "realtorEmail": "480@edc.dk",
  "realtorCvr": "29220425",
  "defaultImage": "https://images.boligsiden.dk/images/case/99110557-47cf-459b-badb-522cf04f114f/1440x960/0e4bfc0b-a1fe-4d7f-8940-c7104bc1e97f.webp",
  "imageCount": 5,
  "saleHistory": [
    { "date": "2021-08-30", "amount": 2050000, "perAreaPrice": 10199, "type": "normal" },
    { "date": "2004-08-23", "amount": 1495000, "perAreaPrice": null, "type": "normal" }
  ]
}
```

***

### Use cases

- **Real-estate market analysis** — track prices per m², days on market and price changes across municipalities over time.
- **Lead generation for realtors & proptech** — build a contact list of active listing agents (name, phone, email, CVR) by area.
- **Property investment & valuation** — combine asking price, public valuation and the full sale-price history to spot under- and over-priced homes.
- **Mortgage, insurance & renovation targeting** — reach owners of newly-listed homes with financing, coverage or renovation offers.
- **Data feeds & aggregators** — power your own property portal, dashboard or model with fresh, structured Danish listing data.

***

### How many results can I get?

Each individual search is capped by Boligsiden at **10,000 listings**. To pull more than that, split your run across **municipalities** (Denmark has ~98) or **ZIP codes** — the actor runs one deep search per location and merges everything, de-duplicated by listing id. The whole Danish for-sale market is roughly 40,000+ listings, so a run covering the major municipalities returns the lot.

***

### FAQ

**Do I need a Boligsiden account or API key?** No. The actor uses Boligsiden's public JSON API — no login, no key.

**How fresh is the data?** It's read live from Boligsiden at run time, so it reflects what's on the site right now. Schedule the actor daily to keep a dataset current.

**Are sold properties included?** The actor scrapes homes currently **for sale**. Each row's `saleHistory` field, however, contains the address's past registered sale prices and dates.

**Why is `saleHistory` (or `latestValuation`, `lotArea`) empty on some rows?** These come straight from public registries and simply aren't recorded for every property — e.g. condos have no plot (`lotArea`), and a home that has never traded has no `saleHistory`. Rows without them are still fully valid.

**Is the text in Danish?** Yes — descriptions, city and street names are in Danish, correctly encoded in UTF-8 (æ, ø, å preserved).

**What does it cost?** Billing is pay-per-result: you're charged once for each listing returned. Blocked or empty pages are never charged.

# Actor input Schema

## `addressTypes` (type: `array`):

Which property types to include. Leave empty to return EVERY type on the market (~44,000 listings). Allowed values (use these exact English strings): villa, condo, terraced house, holiday house, cooperative, villa apartment, double house, multiple family house, farm, hobby farm, cattle farm, pig farm, plant farm, forest, allotment, full year plot, holiday plot, houseboat, garage, parking, business, room. The default set covers the common residential-for-sale types most buyers want.

## `municipalities` (type: `array`):

Restrict to one or more Danish municipalities, given as Boligsiden slugs (lowercase, e.g. "koebenhavn", "aarhus", "odense", "aalborg", "faxe", "gentofte"). This is the BULK axis: the actor runs one deep search per municipality and merges the results (de-duplicated by listing), so a list of municipalities pulls far past the 10,000-per-search API window. Leave empty to search all of Denmark at once (up to 10,000 listings). If both municipalities and ZIP codes are given, municipalities win.

## `zipCodes` (type: `array`):

Restrict to one or more Danish postal (ZIP) codes, e.g. "2100", "8000", "5000". Like municipalities, this is a bulk axis: one deep search runs per ZIP and results are merged and de-duplicated. Used only when Municipalities is empty. Leave both empty to search all of Denmark.

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

Only return listings with an asking price at or above this amount, in Danish kroner (DKK). Leave empty for no lower bound.

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

Only return listings with an asking price at or below this amount, in Danish kroner (DKK). Leave empty for no upper bound.

## `areaMin` (type: `integer`):

Only return listings whose housing (living) area is at least this many square metres. Leave empty for any size.

## `areaMax` (type: `integer`):

Only return listings whose housing (living) area is at most this many square metres. Leave empty for any size.

## `maxResultsPerSearch` (type: `integer`):

Maximum listings to return for EACH search (each municipality, each ZIP, or the single all-Denmark search). The actor paginates automatically (500 per page). Boligsiden's API exposes up to 10,000 results per search, so set this to 10000 to pull a whole municipality; lower it to sample. Every listing returned is billed.

## `maxResults` (type: `integer`):

Optional overall cap across ALL searches combined (after de-duplication). Leave empty for no overall cap - each search is still bounded by Max results per search. Useful to cap the total billed rows for a run.

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

Fallback proxy for reaching Boligsiden's API. The actor sends requests DIRECTLY first (the API answers datacenter requests fine, so no proxy is needed on the happy path) and only routes through this proxy - rotating exits - if a request is ever rate-limited or blocked. The default (Apify Residential, Denmark) is a safe fallback; leave it in place.

## Actor input object example

```json
{
  "addressTypes": [
    "villa",
    "condo",
    "terraced house"
  ],
  "municipalities": [
    "koebenhavn",
    "aarhus",
    "odense",
    "aalborg"
  ],
  "zipCodes": [
    "2100",
    "8000",
    "5000"
  ],
  "maxResultsPerSearch": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DK"
  }
}
```

# 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 = {
    "addressTypes": [
        "villa",
        "condo",
        "terraced house",
        "holiday house",
        "cooperative",
        "villa apartment"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DK"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/boligsiden-real-estate-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 = {
    "addressTypes": [
        "villa",
        "condo",
        "terraced house",
        "holiday house",
        "cooperative",
        "villa apartment",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DK",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/boligsiden-real-estate-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 '{
  "addressTypes": [
    "villa",
    "condo",
    "terraced house",
    "holiday house",
    "cooperative",
    "villa apartment"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DK"
  }
}' |
apify call scrapeworks/boligsiden-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boligsiden.dk Real Estate Scraper",
        "description": "Scrape Danish property listings from Boligsiden.dk in bulk: villas, condos, townhouses and holiday homes. Get asking price, price per m2, rooms, area, year built, energy label, address, geo, public valuation, realtor contact and sale history. No login.",
        "version": "0.1",
        "x-build-id": "bLA4oNbptG6gFSAU8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~boligsiden-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-boligsiden-real-estate-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/scrapeworks~boligsiden-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-boligsiden-real-estate-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/scrapeworks~boligsiden-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-boligsiden-real-estate-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": {
                    "addressTypes": {
                        "title": "Property types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which property types to include. Leave empty to return EVERY type on the market (~44,000 listings). Allowed values (use these exact English strings): villa, condo, terraced house, holiday house, cooperative, villa apartment, double house, multiple family house, farm, hobby farm, cattle farm, pig farm, plant farm, forest, allotment, full year plot, holiday plot, houseboat, garage, parking, business, room. The default set covers the common residential-for-sale types most buyers want.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "municipalities": {
                        "title": "Municipalities (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to one or more Danish municipalities, given as Boligsiden slugs (lowercase, e.g. \"koebenhavn\", \"aarhus\", \"odense\", \"aalborg\", \"faxe\", \"gentofte\"). This is the BULK axis: the actor runs one deep search per municipality and merges the results (de-duplicated by listing), so a list of municipalities pulls far past the 10,000-per-search API window. Leave empty to search all of Denmark at once (up to 10,000 listings). If both municipalities and ZIP codes are given, municipalities win.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to one or more Danish postal (ZIP) codes, e.g. \"2100\", \"8000\", \"5000\". Like municipalities, this is a bulk axis: one deep search runs per ZIP and results are merged and de-duplicated. Used only when Municipalities is empty. Leave both empty to search all of Denmark.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Min price, DKK (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or above this amount, in Danish kroner (DKK). Leave empty for no lower bound."
                    },
                    "priceMax": {
                        "title": "Max price, DKK (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or below this amount, in Danish kroner (DKK). Leave empty for no upper bound."
                    },
                    "areaMin": {
                        "title": "Min living area, m2 (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings whose housing (living) area is at least this many square metres. Leave empty for any size."
                    },
                    "areaMax": {
                        "title": "Max living area, m2 (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings whose housing (living) area is at most this many square metres. Leave empty for any size."
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum listings to return for EACH search (each municipality, each ZIP, or the single all-Denmark search). The actor paginates automatically (500 per page). Boligsiden's API exposes up to 10,000 results per search, so set this to 10000 to pull a whole municipality; lower it to sample. Every listing returned is billed.",
                        "default": 1000
                    },
                    "maxResults": {
                        "title": "Max results overall (optional)",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Optional overall cap across ALL searches combined (after de-duplication). Leave empty for no overall cap - each search is still bounded by Max results per search. Useful to cap the total billed rows for a run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Fallback proxy for reaching Boligsiden's API. The actor sends requests DIRECTLY first (the API answers datacenter requests fine, so no proxy is needed on the happy path) and only routes through this proxy - rotating exits - if a request is ever rate-limited or blocked. The default (Apify Residential, Denmark) is a safe fallback; leave it in place.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
