# Zimmo Scraper (`solidcode/zimmo-scraper`) Actor

\[💰 $2.50 / 1K] Extract Belgian property listings from Zimmo (zimmo.be) — houses, apartments, land, and commercial units for sale or rent. Get price, EPC label, flooding/planning info, surfaces, coordinates, photos, and agent contacts.

- **URL**: https://apify.com/solidcode/zimmo-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Zimmo Scraper

Pull Belgian property listings from Zimmo (zimmo.be) at scale — asking price, full address, GPS coordinates, EPC energy labels, flooding risk, agent contacts, and 20+ photos per property, for sale or for rent across all of Belgium. Search by city or postcode in Dutch or French, or paste zimmo.be URLs straight from your browser. Built for property investors, real-estate agencies, market analysts, PropTech builders, and relocation services who need clean, structured Belgian housing data without copying listings off the site one page at a time.

### Why This Scraper?

- **Belgian EPC energy data on every listing** — extracts both the EPC label (A–G) and the numeric EPC value in kWh/m²/year, the certificate figure Belgian buyers and valuers actually compare.
- **Flooding risk scoring built for Belgium** — captures the flood-zone classification and the official **P-score** (the Flemish flood-hazard rating), a data point most generic property scrapers ignore entirely.
- **Exact GPS coordinates** — latitude and longitude on each property, ready to map, cluster, or geo-join against your own datasets.
- **6 property categories** — House, Apartment, Building Plot / Land, Commercial (incl. Office), Garage / Parking, and Room / Student Housing, filterable in one input.
- **Agent contacts per listing** — agency name, phone number, website, and agency city, so lead lists come pre-populated.
- **Guided search — no URL-building required** — pick buy or rent, a property type, cities or postcodes, and a price range; the scraper builds every search for you.
- **Bilingual output** — collect listings in Dutch (Nederlands) or French (Français), matching how the property is published on zimmo.be.
- **Rich surface and cadastral detail** — living area, plot area, bedroom count, bathroom count, build year, cadastral income, and parcel ID per property.
- **Search by city name or postcode** — enter "Antwerpen", "Gent", or a raw postcode like "9000" and the scraper resolves it to the right municipality across Belgium.

### Use Cases

**Market Research & Analytics**
- Track asking prices and price-per-m² trends across Belgian municipalities
- Compare inventory and EPC energy profiles between cities and provinces
- Build regional dashboards of for-sale versus for-rent supply

**Investment Analysis**
- Screen listings by price range, living area, and EPC label for yield modeling
- Flag flood-exposed properties using the flooding zone and P-score before underwriting
- Map opportunities by GPS coordinates and cadastral income

**Lead Generation**
- Build contact lists of listing agencies with name, phone, and website
- Segment agency coverage by city and property type
- Feed fresh listings directly into a CRM

**Relocation & Housing Search**
- Assemble shortlists of homes or rentals by city, postcode, and budget
- Filter student rooms and apartments near a specific municipality
- Compare energy performance to estimate running costs before viewing

**PropTech & Product Data**
- Power a Belgian property portal or valuation tool with structured listings
- Enrich internal datasets with EPC, flooding, and planning attributes
- Keep a listings database current with scheduled runs

### Getting Started

#### Simple — everything for sale in a city

```json
{
  "transactionType": "for-sale",
  "locations": ["Gent"],
  "maxResults": 50
}
````

#### Filtered — apartments to rent within a budget

```json
{
  "transactionType": "for-rent",
  "propertyType": "apartment",
  "locations": ["Antwerpen", "2000"],
  "priceMax": 1200,
  "language": "nl",
  "maxResults": 200
}
```

#### Advanced — houses for sale, price band, French output

```json
{
  "transactionType": "for-sale",
  "propertyType": "house",
  "locations": ["Bruxelles", "Liège"],
  "priceMin": 250000,
  "priceMax": 600000,
  "language": "fr",
  "maxResults": 500
}
```

#### Power user — paste zimmo.be URLs

```json
{
  "startUrls": [
    "https://www.zimmo.be/nl/zoeken/?search=...",
    "https://www.zimmo.be/nl/gent-9000/te-koop/huis/ABCDE/"
  ],
  "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Power-user input. Paste zimmo.be search-result URLs (Dutch `/nl/zoeken/` or French `/fr/rechercher/`) or individual property URLs copied from your browser. Overrides the guided search fields below. |

#### Guided Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `transactionType` | string | `"for-sale"` | Whether you want properties to buy or to rent. Options: **For Sale**, **For Rent**. |
| `propertyType` | string | `"all"` | Property category to include. Options: **All Types**, **House**, **Apartment**, **Building Plot / Land**, **Commercial (incl. Office)**, **Garage / Parking**, **Room / Student Housing**. |
| `locations` | array | `[]` | Cities, municipalities, or postal codes to search (e.g. "Antwerpen", "Gent", "9000"). Leave empty to search all of Belgium. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | *none* | Only include listings at or above this price in euros. |
| `priceMax` | integer | *none* | Only include listings at or below this price in euros. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | string | `"nl"` | Language for listing text and location names. Options: **Dutch (Nederlands)**, **French (Français)**. |
| `maxResults` | integer | `100` | Maximum number of properties to collect across all searches and URLs combined. Set to `0` for unlimited. Results are collected in full pages, so the final page may overshoot the cap by a few records. |

### Output

Each property is one flat row. Example:

```json
{
  "id": "a1b2c3d4-5678-90ab-cdef-1234567890ab",
  "zimmoCode": "LMYS7",
  "url": "https://www.zimmo.be/nl/gent-9000/te-koop/huis/LMYS7/",
  "transactionType": "For sale",
  "propertyType": "Huis",
  "propertySubType": "Woning",
  "status": "For sale",
  "price": 395000,
  "city": "Gent",
  "postalCode": "9000",
  "province": "Oost-Vlaanderen",
  "address": "Voorbeeldstraat 12",
  "latitude": 51.0543,
  "longitude": 3.7174,
  "bedrooms": 3,
  "bathrooms": 1,
  "toilets": 2,
  "livingArea": 164.5,
  "landArea": 220,
  "constructionType": "Half-open",
  "buildYear": 1962,
  "epcValue": 210,
  "epcLabel": "C",
  "epcCertificateNumber": "20240101-0001234567-RES-1",
  "floodingZone": "Mogelijk overstromingsgevoelig",
  "floodPScore": "B",
  "planningInfo": "Woongebied",
  "cadastralIncome": 1180,
  "parcelId": "44021_A_0123_00_000",
  "description": "Instapklare woning met tuin op een centrale ligging...",
  "mainImageUrl": "https://media.zimmo.be/z-detail-1300/example.jpg",
  "photoCount": 24,
  "images": ["https://media.zimmo.be/z-detail-1300/1.jpg", "https://media.zimmo.be/z-detail-1300/2.jpg"],
  "documents": ["https://files.zimmo.be/.../EPC-attest.pdf", "https://files.zimmo.be/.../bodemattest.pdf"],
  "agentName": "Immo Voorbeeld",
  "agentPhone": "+32 9 123 45 67",
  "agentWebsite": "https://www.immovoorbeeld.be",
  "agentCity": "Gent",
  "agentAddress": "Kerkstraat 1, 9000 Gent",
  "sourceUrl": "https://www.zimmo.be/nl/zoeken/?search=...",
  "scrapedAt": "2026-07-04T10:00:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Zimmo internal property identifier |
| `zimmoCode` | string | Public Zimmo reference code |
| `url` | string | Property detail page URL |
| `transactionType` | string | "For sale" or "For rent" |
| `propertyType` | string | Property category (e.g. Huis, Appartement) |
| `propertySubType` | string | Finer sub-type where available |
| `status` | string | Listing status (For sale, Sold, Rented, …) |
| `price` | number | Asking price or monthly rent in EUR |
| `description` | string | Listing description text |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | Municipality |
| `postalCode` | string | Postal code |
| `province` | string | Belgian province |
| `address` | string | Street address where available |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |

#### Size & Building

| Field | Type | Description |
|-------|------|-------------|
| `bedrooms` | integer | Number of bedrooms |
| `bathrooms` | integer | Number of bathrooms |
| `toilets` | integer | Number of toilets |
| `livingArea` | number | Living surface in m² |
| `landArea` | number | Plot surface in m² |
| `constructionType` | string | Construction type (open, half-open, …) |
| `buildYear` | integer | Year of construction |

#### Energy, Risk & Legal

| Field | Type | Description |
|-------|------|-------------|
| `epcValue` | number | EPC energy value (kWh/m²/year) |
| `epcLabel` | string | EPC energy label (A–G) |
| `epcCertificateNumber` | string | EPC certificate number |
| `floodingZone` | string | Flood-risk zone classification |
| `floodPScore` | string | Flemish flood-hazard P-score |
| `planningInfo` | string | Spatial-planning designation |
| `cadastralIncome` | number | Cadastral income (kadastraal inkomen) |
| `parcelId` | string | Land parcel identifier |

#### Media & Agent

| Field | Type | Description |
|-------|------|-------------|
| `mainImageUrl` | string | Primary photo URL |
| `photoCount` | integer | Number of photos on the listing |
| `images` | array | All photo URLs |
| `documents` | array | Attached document/certificate PDF URLs (EPC, flooding, soil, asbestos, cadastral) where the listing publishes them |
| `agentName` | string | Listing agency name |
| `agentPhone` | string | Agency phone number |
| `agentWebsite` | string | Agency website |
| `agentCity` | string | Agency city |
| `agentAddress` | string | Agency address |
| `sourceUrl` | string | The search or detail URL this listing came from |
| `scrapedAt` | string | ISO timestamp of collection |

### Tips for Best Results

- **Use postcodes for precise areas** — a raw postcode like "9000" targets one municipality exactly, while a city name may resolve to the whole town; supply several postcodes to cover a metro region.
- **Filter on EPC after collection** — the scraper returns both `epcLabel` and the numeric `epcValue`, so pull a broad set and then sort or filter by energy performance for the sharpest shortlist.
- **Match the language to the region** — choose French (Français) for Wallonia and Brussels listings and Dutch (Nederlands) for Flanders, so location names and descriptions read as published.
- **Start small, then scale** — run with `maxResults` of 10–50 to confirm your filters return the right properties, then raise the cap for the full pull.
- **Screen flood exposure early** — sort investment shortlists by `floodingZone` and `floodPScore` to flag high-risk parcels before deeper analysis.
- **Paste browser URLs for exotic filters** — if you need a filter combination the guided fields don't cover, apply it on zimmo.be and drop the resulting URL into `startUrls`.
- **Combine several locations in one run** — the `locations` field accepts multiple cities and postcodes at once, so one run can span an entire buyer catchment area.

### Pricing

**From $2.50 per 1,000 results** — flat pay-per-result billing with no surprises. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one property listing saved to your dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.** Apify platform fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available property listing data from zimmo.be. Use it responsibly and in compliance with applicable laws, including data-protection regulations such as the GDPR. Respect zimmo.be's terms of service, and only use collected data — particularly agency contact details — for lawful, ethical purposes. You are responsible for how the extracted data is stored, processed, and shared.

# Actor input Schema

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

Power-user input. Paste Zimmo search-result URLs (Dutch zimmo.be/nl/zoeken/ or French zimmo.be/fr/rechercher/) or individual property URLs, copied from your browser after applying filters. Overrides the Transaction Type / Property Type / Locations / price settings below.

## `transactionType` (type: `string`):

Are you looking for properties to buy or to rent? Ignored when Start URLs are provided.

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

Filter by property category. Choose 'All Types' to include everything.

## `locations` (type: `array`):

Cities, municipalities, or postal codes to search (e.g. 'Antwerpen', 'Gent', '9000'). Leave empty to search all of Belgium.

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

Only include listings at or above this price in euros. Leave empty for no minimum.

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

Only include listings at or below this price in euros. Leave empty for no maximum.

## `language` (type: `string`):

Language for the listing text and location names. Dutch uses zimmo.be/nl, French uses zimmo.be/fr.

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

Maximum number of properties to collect across all searches and URLs combined. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. Results are collected in full pages, so the final page may overshoot this cap by a few records.

## Actor input object example

```json
{
  "startUrls": [],
  "transactionType": "for-sale",
  "propertyType": "all",
  "locations": [],
  "language": "nl",
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped property listings with key fields.

## `contacts` (type: `string`):

Agent / agency name, phone, and website per listing.

## `energyLegal` (type: `string`):

EPC energy label/value, flooding risk, and spatial planning per listing.

# 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 = {
    "startUrls": [],
    "transactionType": "for-sale",
    "propertyType": "all",
    "locations": [],
    "language": "nl",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/zimmo-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 = {
    "startUrls": [],
    "transactionType": "for-sale",
    "propertyType": "all",
    "locations": [],
    "language": "nl",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/zimmo-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 '{
  "startUrls": [],
  "transactionType": "for-sale",
  "propertyType": "all",
  "locations": [],
  "language": "nl",
  "maxResults": 100
}' |
apify call solidcode/zimmo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zimmo Scraper",
        "description": "[💰 $2.50 / 1K] Extract Belgian property listings from Zimmo (zimmo.be) — houses, apartments, land, and commercial units for sale or rent. Get price, EPC label, flooding/planning info, surfaces, coordinates, photos, and agent contacts.",
        "version": "1.0",
        "x-build-id": "ggbrGgBRra9xdcRhT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~zimmo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-zimmo-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/solidcode~zimmo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-zimmo-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/solidcode~zimmo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-zimmo-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Zimmo search-result URLs (Dutch zimmo.be/nl/zoeken/ or French zimmo.be/fr/rechercher/) or individual property URLs, copied from your browser after applying filters. Overrides the Transaction Type / Property Type / Locations / price settings below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "transactionType": {
                        "title": "Transaction Type",
                        "enum": [
                            "for-sale",
                            "for-rent"
                        ],
                        "type": "string",
                        "description": "Are you looking for properties to buy or to rent? Ignored when Start URLs are provided.",
                        "default": "for-sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "all",
                            "house",
                            "apartment",
                            "land",
                            "commercial",
                            "garage",
                            "room"
                        ],
                        "type": "string",
                        "description": "Filter by property category. Choose 'All Types' to include everything.",
                        "default": "all"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, municipalities, or postal codes to search (e.g. 'Antwerpen', 'Gent', '9000'). Leave empty to search all of Belgium.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price in euros. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price in euros. Leave empty for no maximum."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "nl",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for the listing text and location names. Dutch uses zimmo.be/nl, French uses zimmo.be/fr.",
                        "default": "nl"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to collect across all searches and URLs combined. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. Results are collected in full pages, so the final page may overshoot this cap by a few records.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
