# Immowelt Scraper - German Real Estate Listings (`studio-amba/immowelt-scraper`) Actor

Scrape real estate listings from Immowelt.de — Germany's #2 property portal. Search apartments and houses for sale or rent. Get prices, addresses, rooms, surfaces, energy ratings, photos, and agent details.

- **URL**: https://apify.com/studio-amba/immowelt-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.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

## Immowelt Scraper

Extract property listings from [Immowelt.de](https://www.immowelt.de) — Germany's #2 real estate portal — into structured JSON with prices, locations, rooms, surfaces, energy ratings, photos, and full property details.

### What is Immowelt Scraper?

**Immowelt Scraper** lets you extract structured real estate data from one of Germany's largest property platforms, helping you monitor the market, compare prices, and automate property research — all without manual browsing or login.

- **Track market prices by city and district:** extract listings with prices, surface areas, and price-per-m2 to build price maps across German cities
- **Monitor new listings automatically:** schedule daily runs to catch new properties the moment they appear
- **Build property datasets for analysis:** export thousands of listings for valuation models, investment screening, or academic research
- **Compare rental vs. sale markets:** switch between Kaufen and Mieten to analyse yield gaps and rental demand
- **Feed your CRM or dashboard:** export structured data to Google Sheets, Airtable, or any BI tool via Apify integrations

Immowelt.de has **no public API and no bulk export feature**. This scraper is the only way to get structured data out at scale.

### What data does Immowelt Scraper extract?

- **Title** and full property description
- **Address** — street, postal code, city, district
- **Price** — asking price for sale or monthly rent
- **Price per m2** — calculated if not provided
- **Listing type** — sale or rent
- **Property details** — type, rooms, bedrooms, bathrooms, surface (m2), land surface (m2), floor, build year
- **Energy data** — energy efficiency rating, consumption value, heating type
- **Condition** and availability date
- **Agency/agent** name and URL
- **All images** — main photo and full gallery
- **Features** — amenities and equipment list
- **Direct URL** to the listing on Immowelt.de

### How to scrape Immowelt data

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 |
|-------|------|---------|-------------|
| **startUrls** | Array | — | Immowelt search result URLs or individual listing URLs |
| **searchQuery** | String | `"Berlin"` | City or region to search (e.g., `"Muenchen"`, `"Hamburg"`, `"Koeln"`) |
| **listingType** | String | `"kaufen"` | `"kaufen"` (buy) or `"mieten"` (rent) |
| **propertyType** | String | `"wohnungen"` | `"wohnungen"` (apartments), `"haeuser"` (houses), or `"wohnungen-und-haeuser"` (all) |
| **maxResults** | Integer | `100` | Maximum number of listings to return (1-10,000) |
| **proxyConfiguration** | Object | — | Proxy settings (DE residential recommended) |

#### Tips for best results

- **Use `searchQuery` for quick location searches:** type a city name like `"Berlin"` or `"Muenchen"` to target a specific area
- **Use `startUrls` for advanced filtering:** apply filters on Immowelt.de (price range, number of rooms, balcony, etc.), copy the URL, and paste it as a start URL to preserve all filters
- **Proxy is recommended.** Immowelt has bot detection. Use DE residential proxy for large runs to avoid rate limits
- **Start with a small `maxResults`** (e.g., 20) to verify the output, then scale up
- **Schedule daily runs** to track new listings — Immowelt sees hundreds of new properties per day across Germany

### 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
{
    "listingTitle": "Wohnung zum Kauf in Berlin-Mitte",
    "price": 350000,
    "pricePerSqm": 5000,
    "currency": "EUR",
    "url": "https://www.immowelt.de/expose/2y5e94d",
    "scrapedAt": "2026-06-07T10:30:00.000Z",
    "listingType": "sale",
    "propertyType": "apartment",
    "address": "Mitte, Berlin (10115)",
    "city": "Berlin",
    "postalCode": "10115",
    "district": "Mitte",
    "latitude": null,
    "longitude": null,
    "rooms": 3,
    "bedrooms": 2,
    "bathrooms": 1,
    "surface": 70,
    "landSurface": null,
    "floor": "2. OG",
    "buildYear": 1998,
    "energyRating": "C",
    "energyConsumption": "120 kWh/(m2*a)",
    "heatingType": "Zentralheizung",
    "condition": "Gepflegt",
    "availableFrom": "sofort",
    "imageUrl": "https://media.immowelt.de/photos/abc123/1.jpg",
    "imageUrls": [
        "https://media.immowelt.de/photos/abc123/1.jpg",
        "https://media.immowelt.de/photos/abc123/2.jpg",
        "https://media.immowelt.de/photos/abc123/3.jpg"
    ],
    "description": "Helle 3-Zimmer-Wohnung in zentraler Lage mit Balkon und Einbaukueche. Naehe U-Bahn Rosenthaler Platz.",
    "features": ["Balkon", "Einbaukueche", "Aufzug", "Keller"],
    "agencyName": "ABC Immobilien GmbH",
    "agencyUrl": "https://www.immowelt.de/anbieter/abc-immobilien"
}
````

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

Immowelt Scraper uses **Playwright (real browser)** because Immowelt relies on JavaScript rendering and has anti-bot protections.

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 20 listings | ~$0.20 | ~1 min |
| 100 listings | ~$0.85 | ~5 min |
| 1,000 listings | ~$8.50 | ~45 min |
| 5,000 listings | ~$42 | ~3 hrs |

**Pricing breakdown:**

- Per result: $0.008
- Start fee: $0.01

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

Yes. Immowelt 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 Immowelt Scraper as an API?

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

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/immowelt-scraper").call(run_input={
    "searchQuery": "Berlin",
    "listingType": "kaufen",
    "propertyType": "wohnungen",
    "maxResults": 200,
})

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

**JavaScript:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/immowelt-scraper').call({
    searchQuery: 'Berlin',
    listingType: 'kaufen',
    propertyType: 'wohnungen',
    maxResults: 200,
});

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

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

### FAQ

#### What is Immowelt.de?

Immowelt.de is one of Germany's largest real estate portals, with hundreds of thousands of active property listings. It covers the entire German market — all 16 Bundeslaender — for both sales and rentals across apartments, houses, commercial properties, and land. It's operated by Immowelt GmbH, part of the AVIV Group (Axel Springer SE).

#### How does Immowelt Scraper work?

It uses a real browser (Playwright) to load Immowelt search result pages and listing detail pages, extracting structured data from the rendered HTML. Search results are parsed directly from the listing cards for speed, while detail pages are visited for full property information. Pagination is handled automatically.

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

Yes. Set `listingType` to `"kaufen"` for sales or `"mieten"` for rentals. You can also filter by property type: `"wohnungen"` (apartments), `"haeuser"` (houses), or `"wohnungen-und-haeuser"` for all types.

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

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

#### Is it legal to scrape Immowelt?

This scraper extracts publicly available listing data that Immowelt.de 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. No login or cookies required.

### Limitations

- **Germany only.** Immowelt.de covers exclusively German real estate.
- **Browser-based.** Uses Playwright, which is slower and more expensive than HTTP-only scrapers — but necessary because Immowelt requires JavaScript rendering.
- **Proxy recommended.** Immowelt has bot detection. DE residential proxy is recommended for runs over 100 listings.
- **Some fields may be null.** Not all sellers fill in every field — `landSurface`, `buildYear`, `energyRating`, or `bathrooms` may be missing.
- **Detail page extraction is optional.** Search results provide key fields (title, price, rooms, surface, city). For full data (description, images, energy ratings), use `startUrls` with individual expose URLs.

### Other real estate scrapers

Combine Immowelt Scraper with these actors for comprehensive European property market coverage:

- [ImmoScout24 Scraper](https://apify.com/studio-amba/immoscout24-scraper) — Germany's #1 real estate portal
- [Immoweb Scraper](https://apify.com/studio-amba/immoweb-scraper) — Belgium's #1 property portal
- [Funda Scraper](https://apify.com/studio-amba/funda-scraper) — Netherlands' largest property platform
- [Zimmo Scraper](https://apify.com/studio-amba/zimmo-scraper) — Belgian real estate listings
- [Immoscoop Scraper](https://apify.com/studio-amba/immoscoop-scraper) — Belgian property search
- [Willhaben Scraper](https://apify.com/studio-amba/willhaben-scraper) — Austria's largest marketplace with real estate
- [Otodom Scraper](https://apify.com/studio-amba/otodom-scraper) — Poland's leading property portal

### Your feedback

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

# Actor input Schema

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

One or more Immowelt search result URLs or listing detail URLs. Go to immowelt.de, set your filters, and paste the URL(s) here. Overrides other search filters when provided.

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

City or region to search in (e.g., 'Berlin', 'Muenchen', 'Hamburg', 'Koeln'). Used only when no startUrls are provided.

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

Buy or rent. Used only when no startUrls are provided.

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

Type of property to search for. Used only when no startUrls are provided.

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

Maximum number of listings to return.

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

Proxy settings. Residential proxies recommended for reliable scraping — Immowelt has bot detection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.immowelt.de/suche/berlin/wohnungen/kaufen"
    }
  ],
  "searchQuery": "Berlin",
  "listingType": "kaufen",
  "propertyType": "wohnungen",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "DE"
  }
}
```

# 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.immowelt.de/suche/berlin/wohnungen/kaufen"
        }
    ],
    "searchQuery": "Berlin",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "countryCode": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/immowelt-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.immowelt.de/suche/berlin/wohnungen/kaufen" }],
    "searchQuery": "Berlin",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "countryCode": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/immowelt-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.immowelt.de/suche/berlin/wohnungen/kaufen"
    }
  ],
  "searchQuery": "Berlin",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "DE"
  }
}' |
apify call studio-amba/immowelt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immowelt Scraper - German Real Estate Listings",
        "description": "Scrape real estate listings from Immowelt.de — Germany's #2 property portal. Search apartments and houses for sale or rent. Get prices, addresses, rooms, surfaces, energy ratings, photos, and agent details.",
        "version": "0.1",
        "x-build-id": "Ow3PfMR8ABg4nGybh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~immowelt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-immowelt-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~immowelt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-immowelt-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~immowelt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-immowelt-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": "One or more Immowelt search result URLs or listing detail URLs. Go to immowelt.de, set your filters, and paste the URL(s) here. Overrides other search filters when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Location",
                        "type": "string",
                        "description": "City or region to search in (e.g., 'Berlin', 'Muenchen', 'Hamburg', 'Koeln'). Used only when no startUrls are provided."
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "kaufen",
                            "mieten"
                        ],
                        "type": "string",
                        "description": "Buy or rent. Used only when no startUrls are provided.",
                        "default": "kaufen"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "wohnungen",
                            "haeuser",
                            "wohnungen-und-haeuser"
                        ],
                        "type": "string",
                        "description": "Type of property to search for. Used only when no startUrls are provided.",
                        "default": "wohnungen"
                    },
                    "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. Residential proxies recommended for reliable scraping — Immowelt has bot detection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
