# Homegate Property Scraper (Stable API) (`ducto/homegate-property-scraper`) Actor

Lightning-fast Homegate.ch scraper using direct API extraction. Scrape rent/buy listings, prices, agent details, and coordinates. Supports all Swiss cantons, cities, and zip codes.

- **URL**: https://apify.com/ducto/homegate-property-scraper.md
- **Developed by:** [ducto](https://apify.com/ducto) (community)
- **Categories:** Real estate, Developer tools, Lead generation
- **Stats:** 30 total users, 7 monthly users, 99.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## 🏡 Homegate Property Scraper (Stable API)

Extract comprehensive, highly-structured real estate data from **Homegate.ch**, Switzerland's largest property marketplace. 

Whether you are building a real estate aggregator, analyzing the Swiss housing market, or monitoring competitor prices, this Actor provides lightning-fast, reliable, and clean data extraction from Homegate directly via their internal APIs.

By running directly against the API layer rather than using slow, heavy browser automation, this scraper is engineered for maximum speed, reliability, and cost-efficiency. **Get 10x faster results and significantly lower compute costs** compared to traditional UI scrapers.

---

### ✨ Key Features
- **⚡ Unmatched Speed:** Scrape thousands of property listings in seconds. Built for high-volume, concurrent data extraction.
- **💰 Unbeatable Cost-Efficiency:** No heavy browsers means minimal RAM usage on the Apify platform. You extract more data for less credits.
- **🎯 Smart Location Resolution:** Forget complex internal IDs. Simply type user-friendly locations like "Zurich", "Geneva", "8001", or "Vaud", and our engine automatically resolves them to the correct geographic targets.
- **📊 100% Comprehensive Data:** Extracts every available data point: precise coordinates (Lat/Lon), complete agent and agency contact information, deep property characteristics, high-resolution image URLs, and linked documents (e.g., floor plans).
- **🏢 Competitor & Agency Targeting:** Want to track a specific real estate agency? Use the `listerIds` filter to exclusively scrape properties listed by your target competitors.
- **🌍 Native Multi-Language Output:** Choose your desired output language (German, English, French, or Italian) and receive natively translated property titles and descriptions.

---

### 🛠️ How to Use

You have two simple ways to extract data:

#### 1. Direct Listing URLs
Already know which properties you want? Paste specific Homegate.ch listing URLs (e.g., `https://www.homegate.ch/rent/4002421549`) into the **Start URLs** field. The scraper will instantly fetch the full, enriched details for each listing.

#### 2. Powerful Search Filters
Search the entire Homegate database using our comprehensive filters:
- **Locations:** Enter cities, cantons, or zip codes.
- **Offer Type:** Filter by **RENT** or **BUY**.
- **Price Range:** Set minimum and maximum prices (CHF).
- **Size & Layout:** Filter by number of rooms and living space (m²).
- **Property Categories:** Select from 27 specific types (e.g., Apartment, Villa, Chalet, Office, Commercial, Building Land).
- **Must-Have Features:** Filter for properties with a Balcony, Elevator, Pets Allowed, Nice View, Pool, and more.

---

### 📦 Output Data Structure

The scraper exports clean, flattened JSON or CSV files ready for seamless integration into your databases, Excel sheets, or data science workflows. 

#### Sample JSON Output:
```json
{
  "propertyId": "4002421549",
  "url": "https://www.homegate.ch/rent/4002421549",
  "offerType": "RENT",
  "listingType": "PREMIUM",
  "categories": ["APARTMENT", "ATTIC_FLAT"],
  "price": 4540,
  "priceNet": 4200,
  "priceExtra": 340,
  "currency": "CHF",
  "priceInterval": "MONTH",
  "title": "Sunny attic apartment in Dübendorf",
  "description": "We rent out this beautiful and modern 3.5-room attic apartment...",
  "characteristics": {
    "livingSpaceSqm": 160,
    "numberOfRooms": 3.5,
    "floor": 4,
    "yearBuilt": 2018,
    "hasBalcony": true,
    "hasElevator": false,
    "hasParking": true,
    "hasNiceView": false
  },
  "address": {
    "street": "Überlandstrasse 198",
    "postalCode": "8600",
    "locality": "Dübendorf",
    "region": "ZH",
    "country": "CH"
  },
  "coordinates": {
    "latitude": 47.401134,
    "longitude": 8.621861
  },
  "agency": {
    "id": "schremzh",
    "name": "Schaeppi Grundstücke AG",
    "phone": "+41 44 456 57 67",
    "website": "http://www.schaeppi.ch",
    "contactPerson": "Marc Schweizer"
  },
  "images": [
    { "url": "https://media2.homegate.ch/...", "title": "Exterior" }
  ],
  "documents": [
    { "url": "https://media2.homegate.ch/...", "title": "Floor Plan.pdf" }
  ],
  "availableFrom": "2025-08-13",
  "publishedAt": "2025-08-06T16:28:59.491Z",
  "scrapedAt": "2026-03-12T14:30:00Z"
}
````

***

### ⚙️ Best Practices & Configuration

- **Use Swiss Proxies:** To ensure maximum stability and prevent rate-limiting, we highly recommend using **Apify Residential Proxies** with the country set to Switzerland (`CH`).
- **Start Small:** When testing your filters, set `maxItems` to 10 or 20 before scaling up to massive runs.
- **Automation:** Set up scheduled runs on the Apify platform to build an automated pipeline that monitors the Swiss real estate market daily.

***

### 🤝 Need B2B Real Estate Leads?

Are you looking to build a database of Swiss real estate agencies, brokers, and realtors rather than individual properties?

Check out our companion scraper: **[Homegate Agency & Realtor Leads Scraper](https://apify.com/ducto/homegate-agency-scraper)** *(coming soon)*.
It's specifically designed to extract comprehensive B2B contact information, portfolios, and agency details directly from the Homegate directory!

### ⚖️ Legal & Ethical Use

This tool is designed to extract publicly available data. Users are responsible for ensuring their use of the data complies with local laws, GDPR, and the Terms of Service of the target website. Do not use this tool to spam or overwhelm the target servers.

# Actor input Schema

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

Paste direct Homegate.ch listing URLs here (e.g., https://www.homegate.ch/rent/12345678). If provided, location filters below are ignored.

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

E.g., 'Zurich', 'Bern', '8001'. The actor automatically resolves these to Homegate GeoTags.

## `offerType` (type: `string`):

Select whether you are looking to rent or buy properties.

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

Select specific property types (e.g., Apartment, House). Leave empty to search all categories.

## `agencyIds` (type: `array`):

Only scrape properties from these specific Agency IDs (e.g., 'w002'). Leave empty for all.

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

The lowest price (rent or purchase) to include in the search.

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

The highest price (rent or purchase) to include in the search.

## `roomsMin` (type: `number`):

Minimum number of rooms (supports half-rooms, e.g., 2.5).

## `roomsMax` (type: `number`):

Maximum number of rooms (supports half-rooms, e.g., 5.5).

## `livingSpaceMin` (type: `integer`):

The minimum interior living area in square meters.

## `livingSpaceMax` (type: `integer`):

The maximum interior living area in square meters.

## `features` (type: `array`):

Only return properties that have ALL of these selected features.

## `outputLanguage` (type: `string`):

The language in which property titles and descriptions will be returned.

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

The maximum number of property listings to extract in this run.

## `maxConcurrency` (type: `integer`):

Maximum number of simultaneous API requests. Recommended between 10 and 50.

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

Select proxies to use. Swiss (CH) residential proxies are highly recommended to avoid blocks.

## Actor input object example

```json
{
  "locations": [
    "Zurich"
  ],
  "offerType": "RENT",
  "outputLanguage": "de",
  "maxItems": 100,
  "maxConcurrency": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

The scraped real estate property listings from Homegate.ch in clean JSON format.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CH"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ducto/homegate-property-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CH",
    } }

# Run the Actor and wait for it to finish
run = client.actor("ducto/homegate-property-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}' |
apify call ducto/homegate-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Homegate Property Scraper (Stable API)",
        "description": "Lightning-fast Homegate.ch scraper using direct API extraction. Scrape rent/buy listings, prices, agent details, and coordinates. Supports all Swiss cantons, cities, and zip codes.",
        "version": "0.0",
        "x-build-id": "yET917CPYWg32b4i4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ducto~homegate-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ducto-homegate-property-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/ducto~homegate-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ducto-homegate-property-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/ducto~homegate-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ducto-homegate-property-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "offerType"
                ],
                "properties": {
                    "searchUrls": {
                        "title": "Start URLs (Optional)",
                        "type": "array",
                        "description": "Paste direct Homegate.ch listing URLs here (e.g., https://www.homegate.ch/rent/12345678). If provided, location filters below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations (Cities, Cantons, Zip Codes)",
                        "type": "array",
                        "description": "E.g., 'Zurich', 'Bern', '8001'. The actor automatically resolves these to Homegate GeoTags.",
                        "default": [
                            "Zurich"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "offerType": {
                        "title": "Offer Type",
                        "enum": [
                            "RENT",
                            "BUY"
                        ],
                        "type": "string",
                        "description": "Select whether you are looking to rent or buy properties.",
                        "default": "RENT"
                    },
                    "categories": {
                        "title": "Property Categories",
                        "type": "array",
                        "description": "Select specific property types (e.g., Apartment, House). Leave empty to search all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "APARTMENT",
                                "MAISONETTE",
                                "DUPLEX",
                                "ATTIC_FLAT",
                                "ROOF_FLAT",
                                "STUDIO",
                                "SINGLE_ROOM",
                                "TERRACE_FLAT",
                                "LOFT",
                                "HOUSE",
                                "ROW_HOUSE",
                                "BIFAMILIAR_HOUSE",
                                "TERRACE_HOUSE",
                                "VILLA",
                                "FARM_HOUSE",
                                "CHALET",
                                "RUSTICO",
                                "SINGLE_HOUSE",
                                "COMMERCIAL",
                                "OFFICE",
                                "SHOP",
                                "RESTAURANT",
                                "GARAGE",
                                "PARKING_SPACE",
                                "BUILDING_LAND",
                                "AGRICULTURAL_LAND",
                                "INDUSTRIAL_LAND"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "Maisonette",
                                "Duplex",
                                "Attic Flat",
                                "Roof Flat",
                                "Studio",
                                "Single Room",
                                "Terrace Flat",
                                "Loft",
                                "House",
                                "Row House",
                                "Bifamiliar House",
                                "Terrace House",
                                "Villa",
                                "Farm House",
                                "Chalet",
                                "Rustico",
                                "Single House",
                                "Commercial",
                                "Office",
                                "Shop",
                                "Restaurant",
                                "Garage",
                                "Parking Space",
                                "Building Land",
                                "Agricultural Land",
                                "Industrial Land"
                            ]
                        }
                    },
                    "agencyIds": {
                        "title": "Target Specific Agencies (listerIds)",
                        "type": "array",
                        "description": "Only scrape properties from these specific Agency IDs (e.g., 'w002'). Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum Price (CHF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The lowest price (rent or purchase) to include in the search."
                    },
                    "priceMax": {
                        "title": "Maximum Price (CHF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The highest price (rent or purchase) to include in the search."
                    },
                    "roomsMin": {
                        "title": "Minimum Rooms",
                        "minimum": 0.5,
                        "type": "number",
                        "description": "Minimum number of rooms (supports half-rooms, e.g., 2.5)."
                    },
                    "roomsMax": {
                        "title": "Maximum Rooms",
                        "type": "number",
                        "description": "Maximum number of rooms (supports half-rooms, e.g., 5.5)."
                    },
                    "livingSpaceMin": {
                        "title": "Minimum Living Space (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum interior living area in square meters."
                    },
                    "livingSpaceMax": {
                        "title": "Maximum Living Space (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum interior living area in square meters."
                    },
                    "features": {
                        "title": "Required Features",
                        "type": "array",
                        "description": "Only return properties that have ALL of these selected features.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hasBalcony",
                                "arePetsAllowed",
                                "hasElevator",
                                "isNewBuilding",
                                "hasParkingOrGarage",
                                "isWheelchairAccessible",
                                "hasNiceView",
                                "hasFireplace",
                                "hasSwimmingPool",
                                "isOldBuilding",
                                "isChildFriendly",
                                "isMinergieGeneral"
                            ],
                            "enumTitles": [
                                "Has Balcony",
                                "Pets Allowed",
                                "Has Elevator",
                                "New Building",
                                "Has Parking/Garage",
                                "Wheelchair Accessible",
                                "Nice View",
                                "Has Fireplace",
                                "Has Swimming Pool",
                                "Old Building",
                                "Child Friendly",
                                "Minergie Certified"
                            ]
                        }
                    },
                    "outputLanguage": {
                        "title": "Output Language",
                        "enum": [
                            "de",
                            "en",
                            "fr",
                            "it"
                        ],
                        "type": "string",
                        "description": "The language in which property titles and descriptions will be returned.",
                        "default": "de"
                    },
                    "maxItems": {
                        "title": "Max Items to Scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of property listings to extract in this run.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrent Requests",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of simultaneous API requests. Recommended between 10 and 50.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Select proxies to use. Swiss (CH) residential proxies are highly recommended to avoid blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
