# WG-Gesucht Scraper — German Flatshares & Rentals (`studio-amba/wg-gesucht-scraper`) Actor

Scrape WG-Gesucht.de, Germany's biggest flatshare and rental portal. Get offers (WG rooms, apartments, houses) with rent, size, district, availability, and flatmate details — or switch to seeker mode (Gesuche) for unique demand-side data. Optional cost breakdown per listing. No login, no cookies.

- **URL**: https://apify.com/studio-amba/wg-gesucht-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## WG-Gesucht Scraper — German Flatshares & Rentals

Scrape [WG-Gesucht.de](https://www.wg-gesucht.de), Germany's biggest flatshare and rental portal. WG-Gesucht is where students, young professionals, and relocators find WG rooms (flatshares), studios, apartments, and houses in every German city, plus Austria, Switzerland, and dozens of international cities.

This scraper covers both sides of the market:

- **Offers** — available rooms and apartments, with rent, size, district, availability window, and full flatmate composition.
- **Requests (Gesuche)** — ads posted by people *searching* for a room, with their maximum budget and minimum size. That is demand-side rental market data you will not find in any listing feed.

No login, no cookies, no browser. The actor talks to WG-Gesucht's JSON API directly, so runs are fast and cheap.

### What data you get

Every listing includes:

| Field | Description |
|-------|-------------|
| `id`, `title`, `category` | Listing ID, title, and category (WG-Zimmer, 1-Zimmer-Wohnung, Wohnung, Haus) |
| `rent`, `rentCurrency` | Total monthly rent (warm). For requests: the seeker's max budget. EUR or CHF |
| `size`, `rooms` | Property size in m² and room count |
| `district`, `city`, `postcode`, `street` | Location down to street level (when the lister exposes it) |
| `availableFrom`, `availableTo` | Move-in date and end date for limited lets (ISO format) |
| `flatmateComposition` | Current flatmates by gender: total, males, females, diverse |
| `listerName`, `listerCompany`, `verifiedLister` | Who posted the ad |
| `onlineSince`, `url`, `imageUrl` | Posting date, detail page link, main photo |
| `latitude`, `longitude` | Geo coordinates (when not hidden) |

With `fetchDetails` enabled (offers only), each listing is enriched from its detail page with the full cost breakdown:

| Field | Description |
|-------|-------------|
| `baseRent` | Kaltmiete — cold rent without utilities |
| `utilities` | Nebenkosten — monthly utility costs |
| `otherCosts` | Sonstige Kosten |
| `deposit` | Kaution — one-time security deposit |
| `contactName` | Contact person name |

### How to scrape WG-Gesucht data

1. Enter a **city** — any German, Austrian, or Swiss city name ("Berlin", "München", "Wien", "Zürich"; umlauts or "ue/oe/ae" spellings both work). Cities in other countries (Amsterdam, Barcelona, London, ...) are resolved live from WG-Gesucht's sitemaps.
2. Pick the **ad type** — offers (available rooms) or requests (people searching).
3. Optionally narrow by **categories** (WG room, studio, apartment, house) and **max rent**.
4. Set **max results** and run. Enable **fetchDetails** if you need the Kaltmiete/Kaution cost breakdown.

#### Example input

```json
{
    "city": "Berlin",
    "adType": "offers",
    "categories": ["WG-Zimmer", "Wohnung"],
    "maxRent": 900,
    "maxResults": 200,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example output

```json
{
    "id": "11025715",
    "adType": "offer",
    "title": "Schöne 2-Raumwohnung mit Balkon zur Untermiete",
    "category": "Wohnung",
    "rent": 1200,
    "rentCurrency": "EUR",
    "size": 70,
    "rooms": 2,
    "district": "Kreuzberg",
    "city": "Berlin",
    "postcode": "10963",
    "street": "Tempelhofer Ufer 15",
    "availableFrom": "2026-08-20",
    "availableTo": "2026-09-25",
    "listerName": "Luisa Appenrodt",
    "verifiedLister": false,
    "onlineSince": "2026-07-11T21:13:50",
    "url": "https://www.wg-gesucht.de/wohnungen-in-Berlin.11025715.html",
    "imageUrl": "https://img.wg-gesucht.de/media/up/2024/21/c6a4df545cffdd81fb0fd40dd31535a98199b095c8fddaf3ffa0a2865e954fb6_IMG_27B9EFCC24A8_1.sized.jpeg",
    "latitude": 52.498466,
    "longitude": 13.384254,
    "scrapedAt": "2026-07-11T19:22:50.498Z"
}
```

### The Gesuche dataset (seeker ads)

Set `adType` to `requests` and you get the other half of the market: every person currently looking for a room in a city, with their maximum budget (`rent`), minimum size (`size`), wanted category, and move-in date. Berlin alone has 1,800+ active seeker ads at any time.

That makes it possible to quantify demand, not just supply: how many people are searching per district, what budgets they have, and how supply/demand ratios shift month over month.

### Use cases

- **Rental market research** — rent levels per district and category across 1,200+ German cities, updated any time you run it.
- **Supply and demand analysis** — combine offers and Gesuche for the full market picture.
- **Relocation tooling** — feed availability and price data into apps for students and expats.
- **Price monitoring** — track Kaltmiete, Nebenkosten, and deposits over time with `fetchDetails`.
- **Academic research** — housing market studies need exactly this per-listing granularity.

### Coverage and volume

WG-Gesucht lists roughly 5,000 active offers in Berlin, 3,000+ in München, and thousands more across every German university city, plus Wien, Zürich, and international cities from Amsterdam to Barcelona. A whole-city sweep of all four categories is about 50 API requests and finishes in under two minutes.

### FAQ

#### Is scraping WG-Gesucht legal?

The actor only collects publicly visible listing data — the same information any visitor sees. It does not access anything behind a login, and it does not collect gated contact details like phone numbers. Use the data responsibly and respect GDPR when storing personal names.

#### How fresh is the data?

Live. Every run queries WG-Gesucht's API at that moment, and `onlineSince` tells you exactly when each ad was posted. Berlin gets hundreds of new ads per day.

#### What is the difference between rent and baseRent?

`rent` is the total (warm) monthly rent shown in listings. `baseRent` is the Kaltmiete (cold rent), which together with `utilities` (Nebenkosten) and `otherCosts` adds up to the total. The breakdown only exists on detail pages, so it requires `fetchDetails`.

#### What does fetchDetails cost?

One extra request per listing, politely paced (~2 requests/second). 200 listings add about 2 minutes; a whole city (5,000 offers) takes about 45 minutes. The run is migration-safe — if the platform moves it mid-run, it resumes where it left off without duplicates.

#### Can I scrape multiple cities in one run?

One city per run keeps runs fast and predictable. To cover several cities, start one run per city (they run in parallel) or schedule them.

### Related scrapers

More European real-estate scrapers from the same developer:

- [Immoweb Scraper](https://apify.com/itsnotyouitsme/immoweb-scraper) — Belgium's #1 property portal
- [Zimmo Scraper](https://apify.com/itsnotyouitsme/zimmo-scraper) — Belgian real estate listings
- [Pararius Scraper](https://apify.com/itsnotyouitsme/pararius-scraper) — Dutch rental listings
- [Bien'ici Scraper](https://apify.com/itsnotyouitsme/bienici-scraper) — French property listings

### Support

Found an issue or need an extra field? Open an issue on the actor's page and it will be looked at quickly.

# Actor input Schema

## `city` (type: `string`):

City name in Germany, Austria, or Switzerland (e.g. 'Berlin', 'München', 'Hamburg', 'Wien', 'Zürich'). Umlauts and 'ue/oe/ae' spellings both work. Cities in other countries (Amsterdam, Barcelona, ...) are resolved live from the WG-Gesucht sitemaps. You can also pass a numeric WG-Gesucht city ID or a WG-Gesucht listing URL.

## `adType` (type: `string`):

'Offers' scrapes available rooms and apartments. 'Requests' scrapes the Gesuche side instead: ads by people SEARCHING for a room, with their maximum budget and minimum size — demand-side data that no listing scraper offers.

## `categories` (type: `array`):

Property categories to include. Defaults to all four.

## `maxRent` (type: `integer`):

Only return listings with total rent up to this amount (for requests mode: seekers with a budget up to this amount). Leave empty for no limit.

## `fetchDetails` (type: `boolean`):

Also open each offer's detail page to extract the cost breakdown: base rent (Kaltmiete), utilities (Nebenkosten), other costs, deposit (Kaution), and contact name. One extra request per listing — slower and more expensive. Offers mode only.

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

Maximum number of listings to return.

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

Proxy settings. Default Apify datacenter proxies work fine for WG-Gesucht; switch to RESIDENTIAL (country DE) only if you see blocks on sustained high-volume runs.

## Actor input object example

```json
{
  "city": "Berlin",
  "adType": "offers",
  "categories": [
    "WG-Zimmer",
    "1-Zimmer-Wohnung",
    "Wohnung",
    "Haus"
  ],
  "fetchDetails": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "city": "Berlin",
    "categories": [
        "WG-Zimmer",
        "1-Zimmer-Wohnung",
        "Wohnung",
        "Haus"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/wg-gesucht-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 = {
    "city": "Berlin",
    "categories": [
        "WG-Zimmer",
        "1-Zimmer-Wohnung",
        "Wohnung",
        "Haus",
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/wg-gesucht-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 '{
  "city": "Berlin",
  "categories": [
    "WG-Zimmer",
    "1-Zimmer-Wohnung",
    "Wohnung",
    "Haus"
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/wg-gesucht-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WG-Gesucht Scraper — German Flatshares & Rentals",
        "description": "Scrape WG-Gesucht.de, Germany's biggest flatshare and rental portal. Get offers (WG rooms, apartments, houses) with rent, size, district, availability, and flatmate details — or switch to seeker mode (Gesuche) for unique demand-side data. Optional cost breakdown per listing. No login, no cookies.",
        "version": "0.1",
        "x-build-id": "v91R7GOv56kdhBu6f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~wg-gesucht-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-wg-gesucht-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~wg-gesucht-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-wg-gesucht-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~wg-gesucht-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-wg-gesucht-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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name in Germany, Austria, or Switzerland (e.g. 'Berlin', 'München', 'Hamburg', 'Wien', 'Zürich'). Umlauts and 'ue/oe/ae' spellings both work. Cities in other countries (Amsterdam, Barcelona, ...) are resolved live from the WG-Gesucht sitemaps. You can also pass a numeric WG-Gesucht city ID or a WG-Gesucht listing URL.",
                        "default": "Berlin"
                    },
                    "adType": {
                        "title": "Ad Type",
                        "enum": [
                            "offers",
                            "requests"
                        ],
                        "type": "string",
                        "description": "'Offers' scrapes available rooms and apartments. 'Requests' scrapes the Gesuche side instead: ads by people SEARCHING for a room, with their maximum budget and minimum size — demand-side data that no listing scraper offers.",
                        "default": "offers"
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Property categories to include. Defaults to all four.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "WG-Zimmer",
                                "1-Zimmer-Wohnung",
                                "Wohnung",
                                "Haus"
                            ],
                            "enumTitles": [
                                "WG-Zimmer (flatshare room)",
                                "1-Zimmer-Wohnung (studio)",
                                "Wohnung (apartment)",
                                "Haus (house)"
                            ]
                        },
                        "default": [
                            "WG-Zimmer",
                            "1-Zimmer-Wohnung",
                            "Wohnung",
                            "Haus"
                        ]
                    },
                    "maxRent": {
                        "title": "Max Rent (€)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only return listings with total rent up to this amount (for requests mode: seekers with a budget up to this amount). Leave empty for no limit."
                    },
                    "fetchDetails": {
                        "title": "Fetch Cost Breakdown",
                        "type": "boolean",
                        "description": "Also open each offer's detail page to extract the cost breakdown: base rent (Kaltmiete), utilities (Nebenkosten), other costs, deposit (Kaution), and contact name. One extra request per listing — slower and more expensive. Offers mode only.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Default Apify datacenter proxies work fine for WG-Gesucht; switch to RESIDENTIAL (country DE) only if you see blocks on sustained high-volume runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
