# Immoweb Scraper — Belgian Real Estate Data (Immoweb.be) (`si1ver/immoweb-real-estate-scraper`) Actor

Scrape real estate listings from Immoweb.be (Belgium): price, €/m², surface, bedrooms, EPC/PEB energy rating, geolocation, agency. Incremental mode emits only new/changed listings.

- **URL**: https://apify.com/si1ver/immoweb-real-estate-scraper.md
- **Developed by:** [Микола Картавий](https://apify.com/si1ver) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does the Immoweb Scraper do?

The **Immoweb Scraper** is an Apify Actor that provides a no-code and API-accessible alternative to the missing official Immoweb API, enabling automated extraction of **Belgian real estate listings** at scale. Point it at any [Immoweb.be](https://www.immoweb.be) search URL and it returns price, €/m², surface, bedrooms, **EPC/PEB energy rating**, geolocation, agency, and photos for every property — ready to download as JSON, CSV, or Excel.

It does **not** collect personal data of private individuals — only the listing information that sellers and agencies have chosen to publish.

### Why scrape Immoweb?

Immoweb is widely regarded as Belgium's largest property portal, listing hundreds of thousands of homes for sale and rent — the most complete picture of the Belgian housing market — but the site offers no way to export it. This Actor turns those listings into a dataset you can analyze, monitor, or feed into your own product.

- **Incremental scraping** — with `onlyNewSinceLastRun`, the Actor emits **only new or price-changed listings**, and you are **only charged for what changes**. Ideal for daily price monitoring.
- **EPC/PEB energy rating** — Belgium's energy certificate grade is a first-class field, essential for energy-renovation ("passoire thermique") investment screening.
- **Stable, additive-only schema** — fields are never renamed or removed between versions, so your pipelines won't break.
- **Runs on Apify** — schedule daily runs, call it via API, integrate with Make/Zapier/n8n, rotate proxies automatically, and monitor every run from one dashboard.

### What Belgian real estate data fields can the Immoweb Scraper extract?

| Field | Type | Description |
|---|---|---|
| `price` | number | Asking price in EUR |
| `pricePerM2` | number | Computed €/m² |
| `surface` | number | Habitable surface in m² |
| `bedrooms` | integer | Number of bedrooms |
| `energyRating` | string | EPC/PEB grade A–G (full-detail mode) |
| `propertyType` | string | house, apartment, villa, … |
| `location` | object | city, postalCode, lat, lng |
| `agencyName` | string | Listing agency (business identifier) |
| `images` | array | Photo URLs |
| `changeDetected` | boolean | True when a known listing changed since last run |

### How to scrape Immoweb

1. Open [Immoweb.be](https://www.immoweb.be), apply your filters (region, price, property type), and copy the **search-results URL** from your browser.
2. Paste it into the **Search URLs** input field below.
3. Choose **Listing only** (cheaper) or **Full detail** (adds EPC/PEB, photos, features).
4. Set **Max items** to cap your cost, and pick a proxy (Belgian residential recommended).
5. Click **Start** and download the results as JSON, CSV, or Excel when the run finishes.

For continuous price monitoring, add `orderBy=newest` to your search URL and enable **Only new/changed since last run**.

### How much does it cost to scrape Immoweb?

This Actor uses **pay-per-event** pricing — no subscription, you only pay for results:

| Mode | Cost per 1,000 listings | EPC/PEB included |
|---|---|---|
| Listing only | ~$1.50 | No |
| Full detail | ~$4.00 | Yes |
| Incremental (unchanged listing) | $0.00 | — |

A small Belgium-wide run of a few hundred listings costs only cents — start small to estimate your own volume. Skipped duplicates and unchanged listings in incremental mode are never charged.

### Input options and configuration

See the **Input** tab for the full configuration form. The main options are search URLs, scrape mode, transaction type (sale/rent), max items, incremental mode, and proxy configuration. You can also pass direct listing URLs or Belgian postal codes instead of a search URL.

### Output format for Immoweb data extraction

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**. Each property is one record:

```json
{
  "url": "https://www.immoweb.be/en/classified/21633294",
  "title": "Maison avec jardin et beau potentiel",
  "price": 695000,
  "currency": "EUR",
  "pricePerM2": 4088.24,
  "surface": 170,
  "bedrooms": 4,
  "energyRating": "G",
  "propertyType": "house",
  "location": { "city": "Woluwe-Saint-Lambert", "postalCode": "1200", "lat": 50.8569, "lng": 4.4393 },
  "agencyName": "ABITA IMMO",
  "images": ["https://media-resize.immowebstatic.be/.../736x736/....jpg"],
  "changeDetected": false,
  "scrapedAt": "2026-06-11T14:03:21.000Z"
}
````

### Tips and advanced options

- **Limit cost:** set **Max items** and start in **Listing only** mode; switch to **Full detail** only when you need EPC/PEB and photos.
- **Reliable incremental runs:** use `orderBy=newest` so the same listings reappear run-to-run and unchanged ones are correctly skipped.
- **Avoid blocks:** Immoweb is protected by DataDome — keep proxies enabled. Datacenter is cheapest and often enough; switch to residential if you see blocks.

### FAQ

#### Is there an official Immoweb API?

No. Immoweb does not provide a public API, which is why this Actor exists — it gives you the same data through a simple input form or the Apify API.

#### Is scraping Immoweb legal?

Immoweb listings are publicly accessible. This Actor collects only the listing data that sellers and agencies have chosen to publish on a public website — no login, no personal account data, no contact details of private individuals. Belgian and EU data protection law (GDPR / AVG) applies to any personal data in results; see the Disclaimer below. If your use case requires legal certainty, consult qualified counsel.

#### How often does Immoweb listing data update?

Immoweb refreshes listings continuously. For price-monitoring use cases, daily scheduled runs with `orderBy=newest` and incremental mode enabled give you same-day detection of new listings and price changes.

#### Can I get the EPC/PEB energy rating?

Yes, in **Full detail** mode. It is not available on search results, so listing-only runs leave it empty.

#### Can I monitor price drops on Immoweb?

Yes. Run on a schedule with **Only new/changed since last run** enabled; the `changeDetected` flag marks listings whose price or content changed.

#### Which areas of Belgium are covered?

All of Belgium — paste any Immoweb search URL or pass Belgian postal codes.

### Maintained by

This Actor is actively maintained. The output schema is versioned and additive-only — breaking changes are never introduced without a major version bump and a migration note on the Issues tab.

### Disclaimer

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

### Support

Found a bug or need a new field? Open an issue on the **Issues** tab — it's monitored. For programmatic access, see the **API** tab to run this Actor and fetch results from your own code.

# Actor input Schema

## `scrapeMode` (type: `string`):

listing-only: data available on search results (cheaper). full-detail: also opens every listing for EPC/PEB energy rating, images, features, agency (premium event charged).

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

Sale or rent. Used when building searches from locations; ignored when explicit searchUrls are provided (the URL filters win).

## `searchUrls` (type: `array`):

Immoweb search-result URLs with your filters applied (e.g. https://www.immoweb.be/en/search/house/for-sale?countries=BE). Highest-priority input mode. Tip: use orderBy=newest for reliable incremental monitoring.

## `listingUrls` (type: `array`):

Direct Immoweb classified URLs to scrape one by one. Each is charged as listing-scraped (+ full-detail-scraped, since the detail page is parsed).

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

Geo mode: Belgian postal codes (e.g. "1000", "9790"). The actor builds a search per code. Used only when searchUrls and listingUrls are empty. City-name search: use searchUrls instead.

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

Hard cap on listings pushed to the dataset this run (cost control). 0 = unlimited.

## `onlyNewSinceLastRun` (type: `boolean`):

Incremental mode: compare against the dedupe store and emit ONLY listings that are new or whose content changed (changeDetected=true). Unchanged listings are skipped and NOT charged. Use orderBy=newest in your search URL so the same listings reappear run-to-run.

## `dedupeStoreName` (type: `string`):

Named key-value store holding fingerprints of previously seen listings. Reuse the same name across runs to make incremental mode work. Letters, digits, dashes only.

## `dedupeWithinRun` (type: `boolean`):

Drop a listing if another with the same geo+price+surface fingerprint was already emitted in this run (the same property advertised twice).

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

Proxies are required at scale — DataDome blocks datacenter bursts and bare datacenter IPs. Datacenter proxies are cheapest and often sufficient for Immoweb; switch to RESIDENTIAL if you hit blocks. Belgian (BE) exits are forced on top of this configuration.

## Actor input object example

```json
{
  "scrapeMode": "listing-only",
  "transactionType": "sale",
  "searchUrls": [
    "https://www.immoweb.be/en/search/house/for-sale?countries=BE"
  ],
  "maxItems": 100,
  "onlyNewSinceLastRun": false,
  "dedupeStoreName": "immoweb-dedupe",
  "dedupeWithinRun": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `runStats` (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 = {
    "searchUrls": [
        "https://www.immoweb.be/en/search/house/for-sale?countries=BE"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("si1ver/immoweb-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 = {
    "searchUrls": ["https://www.immoweb.be/en/search/house/for-sale?countries=BE"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("si1ver/immoweb-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 '{
  "searchUrls": [
    "https://www.immoweb.be/en/search/house/for-sale?countries=BE"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call si1ver/immoweb-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immoweb Scraper — Belgian Real Estate Data (Immoweb.be)",
        "description": "Scrape real estate listings from Immoweb.be (Belgium): price, €/m², surface, bedrooms, EPC/PEB energy rating, geolocation, agency. Incremental mode emits only new/changed listings.",
        "version": "0.1",
        "x-build-id": "Q5kk63I6Gfj7Wzmeu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/si1ver~immoweb-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-si1ver-immoweb-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/si1ver~immoweb-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-si1ver-immoweb-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/si1ver~immoweb-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-si1ver-immoweb-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",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "scrapeMode": {
                        "title": "Scrape mode",
                        "enum": [
                            "listing-only",
                            "full-detail"
                        ],
                        "type": "string",
                        "description": "listing-only: data available on search results (cheaper). full-detail: also opens every listing for EPC/PEB energy rating, images, features, agency (premium event charged).",
                        "default": "listing-only"
                    },
                    "transactionType": {
                        "title": "Transaction type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Sale or rent. Used when building searches from locations; ignored when explicit searchUrls are provided (the URL filters win).",
                        "default": "sale"
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Immoweb search-result URLs with your filters applied (e.g. https://www.immoweb.be/en/search/house/for-sale?countries=BE). Highest-priority input mode. Tip: use orderBy=newest for reliable incremental monitoring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Listing URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Direct Immoweb classified URLs to scrape one by one. Each is charged as listing-scraped (+ full-detail-scraped, since the detail page is parsed).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Postal codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Geo mode: Belgian postal codes (e.g. \"1000\", \"9790\"). The actor builds a search per code. Used only when searchUrls and listingUrls are empty. City-name search: use searchUrls instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on listings pushed to the dataset this run (cost control). 0 = unlimited.",
                        "default": 100
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new/changed since last run",
                        "type": "boolean",
                        "description": "Incremental mode: compare against the dedupe store and emit ONLY listings that are new or whose content changed (changeDetected=true). Unchanged listings are skipped and NOT charged. Use orderBy=newest in your search URL so the same listings reappear run-to-run.",
                        "default": false
                    },
                    "dedupeStoreName": {
                        "title": "Dedupe store name",
                        "pattern": "^[a-zA-Z0-9-]*$",
                        "type": "string",
                        "description": "Named key-value store holding fingerprints of previously seen listings. Reuse the same name across runs to make incremental mode work. Letters, digits, dashes only.",
                        "default": "immoweb-dedupe"
                    },
                    "dedupeWithinRun": {
                        "title": "Deduplicate listings within a run",
                        "type": "boolean",
                        "description": "Drop a listing if another with the same geo+price+surface fingerprint was already emitted in this run (the same property advertised twice).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxies are required at scale — DataDome blocks datacenter bursts and bare datacenter IPs. Datacenter proxies are cheapest and often sufficient for Immoweb; switch to RESIDENTIAL if you hit blocks. Belgian (BE) exits are forced on top of this configuration.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
