# Immoweb Scraper — Belgian Real Estate Listings (`studio-amba/immoweb-scraper`) Actor

Scrape real estate listings from Immoweb.be — Belgium's #1 property portal. Extract prices, locations, EPC scores, photos, and full property details. Filter by sale or rent, property type, and location.

- **URL**: https://apify.com/studio-amba/immoweb-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Immoweb Scraper

Extract property listings from [Immoweb.be](https://www.immoweb.be) — Belgium's #1 real estate portal with over 200,000 active listings — into structured JSON with prices, locations, EPC scores, photos, and full property details.

### What is Immoweb Scraper?

**Immoweb Scraper** lets you extract structured real estate data from Belgium's largest property platform, helping you monitor the market, compare prices, and automate property research — all without manual browsing.

- **Track market prices by neighbourhood:** extract listings with prices, surface areas, and EPC scores to build price-per-m² maps across any Belgian city or postcode
- **Monitor new listings in real time:** schedule daily runs and get alerted the moment a property matching your criteria hits the market
- **Build property datasets for analysis:** export thousands of listings with GPS coordinates, build year, and energy ratings for valuation models, academic research, or investment screening
- **Compare rental vs. sale markets:** switch between sale and rent listings to analyse yield gaps and rental demand across regions
- **Feed your CRM or dashboard:** export structured data to Google Sheets, Airtable, or any BI tool via Apify integrations

Immoweb.be has **no public API and no bulk export feature**. This scraper is the only way to get structured data out of Belgium's dominant property platform at scale.

### What data does Immoweb Scraper extract?

🏠 **Title** and full property description
📍 **Address** — street, postal code, city, province
🗺️ **GPS coordinates** — latitude and longitude for mapping
💰 **Price** — asking price for sale or monthly rent
🏷️ **Listing type** — sale or rent
🏗️ **Property details** — type, bedrooms, bathrooms, surface (m²), land surface (m²), build year
⚡ **EPC energy score** — official energy performance certificate rating
🏢 **Agency name** — the estate agent marketing the property
📸 **All images** — main photo and full gallery of property photos
📝 **Description** — complete listing text
🔗 **Direct URL** to the listing on Immoweb.be

### How to scrape Immoweb.be

The input is simple: choose your **search criteria** and hit run. You can configure the scraper through the Apify Console UI or programmatically via the API.

#### Input fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| **searchQuery** | String | — | Search by location, e.g. `"Brussels"`, `"Gent"`, `"1000"` |
| **startUrls** | Array | — | Immoweb search result URLs or individual listing URLs |
| **listingType** | String | `"sale"` | `"sale"` or `"rent"` |
| **propertyType** | String | `"any"` | `"any"`, `"house"`, or `"apartment"` |
| **maxResults** | Integer | `100` | Maximum number of listings to return (1–10,000) |
| **proxyConfiguration** | Object | — | Proxy settings (recommended — Immoweb has bot detection) |

#### Tips for best results

- **Use `searchQuery` for quick location searches:** type a city name like `"Antwerpen"` or a postal code like `"1050"` to target a specific area
- **Use `startUrls` for advanced filtering:** apply filters on Immoweb.be (price range, number of bedrooms, garden, etc.), copy the URL, and paste it as a start URL to preserve all filters
- **Proxy is strongly recommended.** Immoweb blocks most datacenter IPs. Use residential proxy for large runs to avoid rate limits
- **Start with a small `maxResults`** (e.g. 50) to verify the output, then scale up
- **Schedule daily runs** to track new listings — Immoweb typically sees hundreds of new properties per day across Belgium

### Output

Results are stored in a **dataset** that you can download in JSON, CSV, Excel, XML, or HTML format directly from the Apify Console.

#### JSON example

```json
{
    "title": "Apartment for sale in Brussels",
    "price": 325000,
    "currency": "EUR",
    "url": "https://www.immoweb.be/en/classified/apartment/for-sale/brussels/1000/11284753",
    "scrapedAt": "2026-04-04T08:30:00.000Z",
    "listingType": "sale",
    "propertyType": "apartment",
    "address": "Rue de la Loi 42",
    "city": "Brussels",
    "postalCode": "1000",
    "province": "Brussels",
    "bedrooms": 2,
    "bathrooms": 1,
    "surface": 95,
    "landSurface": null,
    "buildYear": 1985,
    "epcScore": "B",
    "imageUrl": "https://pic.immoweb.be/pics/11284753/1.jpg",
    "imageUrls": [
        "https://pic.immoweb.be/pics/11284753/1.jpg",
        "https://pic.immoweb.be/pics/11284753/2.jpg",
        "https://pic.immoweb.be/pics/11284753/3.jpg",
        "https://pic.immoweb.be/pics/11284753/4.jpg"
    ],
    "description": "Bright 2-bedroom apartment in the European quarter with open kitchen, balcony, and cellar. Close to Schuman metro station and Parc du Cinquantenaire. Recently renovated with new double glazing and EPC B rating.",
    "latitude": 50.8465,
    "longitude": 4.3717,
    "agencyName": "Trevi Brussels"
}
````

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

Immoweb Scraper uses **Playwright (real browser)** because Immoweb relies on JavaScript rendering and has anti-bot protections. This makes it slightly more expensive than HTTP-only scrapers, but still very affordable.

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 100 listings | ~$0.25 | ~3 min |
| 1,000 listings | ~$2.50 | ~25 min |
| 5,000 listings | ~$12.50 | ~2 hrs |

**Pricing breakdown:**

- Per result: $0.004

### Can I integrate Immoweb Scraper with other apps?

Yes. Immoweb Scraper connects with any tool through [Apify integrations](https://apify.com/integrations):

- **Google Sheets** — automatically export property data to a spreadsheet
- **Slack / Email** — get notified when new listings match your criteria
- **Zapier / Make** — trigger workflows when data is ready
- **Airtable** — build a searchable property database
- **REST API** — call the scraper programmatically from any language
- **Webhooks** — get notified when a run finishes

### Can I use Immoweb Scraper as an API?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) to run Immoweb Scraper programmatically.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/immoweb-scraper").call(run_input={
    "searchQuery": "Brussels",
    "listingType": "sale",
    "propertyType": "apartment",
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} — {item['city']} — €{item['price']:,}")
```

**JavaScript:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/immoweb-scraper').call({
    searchQuery: 'Brussels',
    listingType: 'sale',
    propertyType: 'apartment',
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Check the [API tab](https://apify.com/studio-amba/immoweb-scraper/api) for full documentation.

### FAQ

#### What is Immoweb.be?

Immoweb.be is Belgium's largest and most-visited real estate platform, with over 200,000 active property listings. It covers the entire Belgian market — Flanders, Wallonia, and Brussels — for both sales and rentals across all property types. It's operated by Immoweb Group (part of Aviv Group / Axel Springer).

#### How does Immoweb Scraper work?

It uses a real browser (Playwright) to load Immoweb listing pages and extracts structured data from `window.classified` — a JavaScript object that Immoweb injects into every listing page. This gives clean, complete data without needing to parse messy HTML. If the JavaScript object isn't available (rare), there's an HTML fallback.

#### Can I scrape both sale and rental listings?

Yes. Set `listingType` to `"sale"` or `"rent"`. You can also filter by property type: `"house"`, `"apartment"`, or `"any"` for all types.

#### Can I filter by price, bedrooms, or other criteria?

Yes. Apply any filters on Immoweb.be directly, then copy the resulting URL and paste it into `startUrls`. The scraper will respect all URL parameters including price range, number of bedrooms, garden, terrace, and more.

#### Is it legal to scrape Immoweb?

This scraper extracts publicly available listing data that Immoweb.be displays to all visitors. The data is factual (prices, addresses, property specifications) and does not contain private personal information. As with any scraping tool, use the data responsibly and in compliance with applicable laws.

### Limitations

- **Belgium only.** Immoweb.be covers exclusively Belgian real estate.
- **Browser-based.** Uses Playwright, which is slower and more expensive than HTTP-only scrapers — but necessary because Immoweb requires JavaScript rendering.
- **Proxy recommended.** Immoweb has bot detection. Residential proxy is recommended for runs over 500 listings.
- **Rate-limited crawling.** The scraper uses low concurrency to avoid triggering blocks, which means large runs take longer.
- **Some fields may be null.** Not all sellers fill in every field — `landSurface`, `buildYear`, or `epcScore` may be missing on some listings.

### Other Belgian real estate scrapers

Combine Immoweb Scraper with these actors for comprehensive Belgian and European property market coverage:

- ⚖️ [Biddit Scraper](https://apify.com/studio-amba/biddit-scraper) — Belgian notarial property auctions with bid prices
- 🏠 [Logic-Immo Scraper](https://apify.com/studio-amba/logicimmo-scraper) — French-language Belgian real estate listings
- 🏡 [Immovlan Scraper](https://apify.com/studio-amba/immovlan-scraper) — Belgian property listings (VTM/DPG network)
- 🇱🇺 [Athome.lu Scraper](https://apify.com/studio-amba/athome-scraper) — Luxembourg real estate
- 🇩🇪 [ImmoScout24 Scraper](https://apify.com/studio-amba/immoscout24-scraper) — German property listings

### Your feedback

Found a bug or have a feature request? Please open an issue on the [Issues tab](https://apify.com/studio-amba/immoweb-scraper/issues). We actively maintain this scraper and respond to all reports.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for properties by location, e.g., 'Brussels', 'Gent', 'Antwerpen', 'Liège'. Leave empty to search all of Belgium.

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

Immoweb search or listing URLs to scrape. Overrides searchQuery if provided.

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

Type of listing to search for.

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

Type of property to search for.

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

Maximum number of listings to return.

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

Proxy settings. Recommended for reliable scraping — Immoweb blocks non-proxy requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"
    }
  ],
  "listingType": "sale",
  "propertyType": "any",
  "maxResults": 100
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/immoweb-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": [{ "url": "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1" }] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/immoweb-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": [
    {
      "url": "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"
    }
  ]
}' |
apify call studio-amba/immoweb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immoweb Scraper — Belgian Real Estate Listings",
        "description": "Scrape real estate listings from Immoweb.be — Belgium's #1 property portal. Extract prices, locations, EPC scores, photos, and full property details. Filter by sale or rent, property type, and location.",
        "version": "0.1",
        "x-build-id": "3fbXSeIAzEAnYHrNg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~immoweb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-immoweb-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/studio-amba~immoweb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-immoweb-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/studio-amba~immoweb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-immoweb-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": {
                    "searchQuery": {
                        "title": "Search Location",
                        "type": "string",
                        "description": "Search for properties by location, e.g., 'Brussels', 'Gent', 'Antwerpen', 'Liège'. Leave empty to search all of Belgium."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Immoweb search or listing URLs to scrape. Overrides searchQuery if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Type of listing to search for.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "house",
                            "apartment"
                        ],
                        "type": "string",
                        "description": "Type of property to search for.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for reliable scraping — Immoweb blocks non-proxy requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
