# Homegate Scraper - Swiss Real Estate Listings (`studio-amba/homegate-scraper`) Actor

Scrape real estate listings from Homegate.ch — Switzerland's #1 property portal. Extract apartments and houses for rent or sale with CHF prices, rooms, living space, addresses, coordinates, and photos. No login or cookies needed.

- **URL**: https://apify.com/studio-amba/homegate-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 $8.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 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 Scraper

Extract property listings from [Homegate.ch](https://www.homegate.ch) -- Switzerland's #1 real estate portal with tens of thousands of active listings -- into structured JSON with CHF prices, rooms, living space, addresses, coordinates, and photos.

### What is Homegate Scraper?

**Homegate Scraper** lets you extract structured real estate data from Switzerland's largest property platform, helping you monitor the market, compare prices, and automate property research -- all without manual browsing or login.

- **Track rental prices across Switzerland:** extract listings with gross monthly rents, room counts, and living space to build price maps across Zurich, Geneva, Basel, and every canton
- **Monitor new listings in real time:** schedule daily runs and get alerted the moment a flat matching your criteria hits the market -- essential in Switzerland's tight rental markets
- **Build property datasets for analysis:** export listings with prices, areas, coordinates, and construction years for valuation models, academic research, or relocation planning
- **Compare rent vs. buy markets:** switch between rental and purchase listings to analyse yields and ownership costs across locations
- **Feed your CRM or dashboard:** export structured data to Google Sheets, Airtable, or any BI tool via Apify integrations

Homegate.ch has **no public API and no bulk export feature**. This scraper turns its listing pages into clean, structured data at scale.

### What data does Homegate Scraper extract?

Each listing returns the following fields:

- **Listing ID** -- the Homegate listing identifier
- **Listing Title** -- the listing headline
- **Transaction Type** -- rent or buy
- **Property Type** -- apartment, single house, furnished flat, etc.
- **Price** -- monthly gross rent or purchase price in CHF
- **Currency** -- CHF
- **Price Interval** -- MONTH or WEEK for rentals
- **Rooms** -- Swiss room count (may be x.5)
- **Living Space** -- in square meters
- **Year Built** -- year of construction
- **Street** -- street address
- **Postal Code** -- 4-digit Swiss ZIP
- **Location** -- municipality / locality
- **Canton** -- canton code (ZH, GE, BE, ...)
- **Latitude / Longitude** -- geographic coordinates
- **Image URL** -- main property photo
- **URL** -- direct link to the listing on Homegate.ch
- **Scraped At** -- ISO 8601 timestamp

### How to scrape Homegate data

The input is simple: choose a **location and transaction type** and hit run. You can configure the scraper through the Apify Console UI or programmatically via the API.

#### Input fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| **transaction** | String | `"rent"` | `"rent"` or `"buy"` |
| **location** | String | `"zurich"` | City or canton name, ZIP code, or homegate geo slug (see below) |
| **maxResults** | Integer | `50` | Maximum number of listings to return (1--10,000) |
| **startUrls** | Array | -- | Homegate matching-list URLs (overrides transaction/location) |
| **proxyConfiguration** | Object | Residential | Keep the residential default -- Homegate uses bot protection |

#### Location values

The `location` field accepts several formats:

| You type | Scraper searches |
|----------|------------------|
| `zurich`, `geneva`, `basel`, `bern`, `lausanne`, `lugano` | The city |
| `zug`, `ticino`, `vaud` | The canton (automatic fallback when no city matches) |
| `8005` | The ZIP code area |
| `city-zurich`, `canton-bern`, `zipcode-1200` | The exact homegate geo segment |

German, French, and Italian spellings like `zürich`, `genève`, or `ginevra` are mapped automatically.

#### Tips for best results

- **Use `startUrls` for advanced filtering:** apply filters on homegate.ch (price range, rooms, floor area, pets allowed, etc.), copy the results URL (it ends in `/matching-list`), and paste it as a start URL to preserve all filters
- **Start with a small `maxResults`** (e.g. 50) to verify the output, then scale up
- **Schedule daily runs** to track new listings -- Swiss rentals move fast, especially in Zurich and Geneva
- **Keep the default proxy settings.** Homegate.ch uses bot protection; the actor rotates residential IPs automatically
- **Empty input works:** running with `{}` defaults to rental listings in Zurich

### 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
{
    "listingId": "4002086141",
    "listingTitle": "Helle 3.5-Zimmer-Wohnung mit Balkon",
    "transactionType": "rent",
    "propertyType": "apartment",
    "price": 2820,
    "currency": "CHF",
    "priceInterval": "MONTH",
    "rooms": 3.5,
    "areaM2": 78,
    "yearBuilt": 2005,
    "street": "Rotbuchstrasse 9",
    "postalCode": "8006",
    "location": "Zürich",
    "canton": "ZH",
    "latitude": 47.386584,
    "longitude": 8.548504,
    "imageUrl": "https://media2.homegate.ch/listings/v2/e335city/4002086141/image/107143110dbcbd41e01dfefdf50aa5a6.jpg",
    "url": "https://www.homegate.ch/rent/4002086141",
    "scrapedAt": "2026-07-10T10:30:00.000Z"
}
````

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

The scraper reads the structured data embedded in Homegate's server-rendered pages -- no browser, no screenshots. That keeps runs fast and affordable.

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 50 listings | ~$0.41 | ~1 min |
| 500 listings | ~$4.01 | ~5 min |
| 2,000 listings | ~$16.01 | ~20 min |

**Pricing breakdown:**

- Per run start: $0.01
- Per result: $0.008

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

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

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

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/homegate-scraper").call(run_input={
    "transaction": "rent",
    "location": "zurich",
    "maxResults": 200,
})

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

**JavaScript:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/homegate-scraper').call({
    transaction: 'rent',
    location: 'zurich',
    maxResults: 200,
});

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

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

### FAQ

#### What is Homegate.ch?

Homegate.ch is Switzerland's largest and most-visited real estate platform, operated by SMG Swiss Marketplace Group. It covers the entire Swiss market -- all 26 cantons, in German, French, and Italian-speaking regions -- for both rentals and sales across apartments, houses, furnished flats, and shared living.

#### How does Homegate Scraper work?

It loads Homegate search-result pages through rotating residential proxies and reads the structured listing data that Homegate embeds in its server-rendered HTML: title, price, rooms, living space, address, coordinates, and photo per listing. No browser rendering is needed, which keeps runs fast.

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

Yes. Set `transaction` to `"rent"` or `"buy"`. The same fields are returned for both; purchases have no `priceInterval`.

#### Can I filter by price, rooms, or floor area?

Yes, via `startUrls`. Apply any filters on homegate.ch, copy the resulting `/matching-list` URL, and pass it as a start URL. All filters in the URL are preserved.

#### Do I need proxies?

The actor uses Apify residential proxies by default and rotates IPs automatically to handle Homegate's bot protection. Just keep the default proxy configuration.

#### Is it legal to scrape Homegate?

This scraper extracts publicly available listing data that Homegate.ch 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 are required.

### Limitations

- **Switzerland only.** Homegate.ch covers exclusively Swiss real estate.
- **Search pages only.** The scraper reads matching-list (search-result) pages; individual listing detail URLs in `startUrls` are skipped.
- **Sequential crawling.** Pages are fetched one at a time to stay under Homegate's bot-protection radar, so very large runs take longer.
- **Some fields may be null.** Not all advertisers fill in every field -- `yearBuilt`, `areaM2`, or `street` may be missing on some listings.

### Other European real estate scrapers

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

- [ImmoScout24 Scraper](https://apify.com/studio-amba/immoscout24-scraper) -- German property listings
- [Immoweb Scraper](https://apify.com/studio-amba/immoweb-scraper) -- Belgian real estate listings
- [Funda Scraper](https://apify.com/studio-amba/funda-scraper) -- Dutch property listings
- [Immobiliare Scraper](https://apify.com/studio-amba/immobiliare-scraper) -- Italian real estate
- [Idealista Scraper](https://apify.com/studio-amba/idealista-scraper) -- Spanish real estate
- [SeLoger Scraper](https://apify.com/studio-amba/seloger-scraper) -- French property listings
- [Willhaben Scraper](https://apify.com/studio-amba/willhaben-scraper) -- Austrian real estate
- [Spitogatos Scraper](https://apify.com/studio-amba/spitogatos-scraper) -- Greek property listings

### Your feedback

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

# Actor input Schema

## `transaction` (type: `string`):

Search for properties for rent or for sale.

## `location` (type: `string`):

Swiss city or canton name (e.g. 'zurich', 'geneva', 'basel', 'canton-bern'), a 4-digit ZIP code (e.g. '8005'), or a geo slug from a homegate.ch URL (e.g. 'city-zurich').

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

Maximum number of listings to return.

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

Homegate search-result URLs (matching-list pages) to scrape, e.g. https://www.homegate.ch/rent/real-estate/city-zurich/matching-list — filters applied on homegate.ch are preserved. Overrides transaction/location if provided.

## `brightDataApiKey` (type: `string`):

Optional override for the built-in unblocking service credentials. Leave empty to use the default.

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

Proxy settings. Homegate.ch uses bot protection, so residential proxies are required — keep the default.

## Actor input object example

```json
{
  "transaction": "rent",
  "location": "zurich",
  "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 = {
    "transaction": "rent",
    "location": "zurich",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/homegate-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 = {
    "transaction": "rent",
    "location": "zurich",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/homegate-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 '{
  "transaction": "rent",
  "location": "zurich",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/homegate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Homegate Scraper - Swiss Real Estate Listings",
        "description": "Scrape real estate listings from Homegate.ch — Switzerland's #1 property portal. Extract apartments and houses for rent or sale with CHF prices, rooms, living space, addresses, coordinates, and photos. No login or cookies needed.",
        "version": "0.1",
        "x-build-id": "8yr9PoyqAmL54p7Ug"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~homegate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-homegate-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~homegate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-homegate-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~homegate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-homegate-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": {
                    "transaction": {
                        "title": "Transaction Type",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Search for properties for rent or for sale.",
                        "default": "rent"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Swiss city or canton name (e.g. 'zurich', 'geneva', 'basel', 'canton-bern'), a 4-digit ZIP code (e.g. '8005'), or a geo slug from a homegate.ch URL (e.g. 'city-zurich').",
                        "default": "zurich"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Homegate search-result URLs (matching-list pages) to scrape, e.g. https://www.homegate.ch/rent/real-estate/city-zurich/matching-list — filters applied on homegate.ch are preserved. Overrides transaction/location if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key (optional)",
                        "type": "string",
                        "description": "Optional override for the built-in unblocking service credentials. Leave empty to use the default."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Homegate.ch uses bot protection, so residential proxies are required — keep the default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
