# Homes.co.nz Property Search Scraper (`automation-lab/homes-co-nz-property-search-scraper`) Actor

Extract Homes.co.nz address, suburb, street, and property search candidates for NZ real estate research, geocoding, and lead enrichment.

- **URL**: https://apify.com/automation-lab/homes-co-nz-property-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Homes.co.nz Property Search Scraper

Extract public Homes.co.nz property search, address lookup, suburb, street, and city suggestions for New Zealand real estate workflows.

The actor queries public Homes.co.nz gateway endpoints and returns clean dataset rows with titles, result types, address components, coordinates, IDs, source URLs, and timestamps.

### What does Homes.co.nz Property Search Scraper do?

Homes.co.nz Property Search Scraper turns Homes.co.nz search terms into structured property discovery data.

Use it to search public address, street, suburb, and city candidates across New Zealand.

Typical terms include city names, suburbs, streets, and full addresses.

The actor is HTTP-first and does not require a browser, login, or account cookies.

### Who is it for?

- 🏠 Real estate agencies building address and area prospecting lists.
- 📍 Proptech teams enriching NZ address search workflows.
- 📊 Market researchers monitoring property discovery coverage.
- 🧭 GIS and geocoding teams comparing candidate locations.
- 💼 Investors looking for repeatable suburb and street discovery exports.
- 🤝 Lead enrichment teams that need public Homes.co.nz search metadata.

### Why use this scraper?

Manual Homes.co.nz search is useful for one-off checks.

This actor is useful when you need repeatable exports, multiple search terms, or an API-friendly workflow.

It returns consistent fields that are easier to merge into spreadsheets, CRMs, GIS tools, BI dashboards, and enrichment pipelines.

### What data can you extract?

| Field | Description |
| --- | --- |
| `searchTerm` | Input term used for the gateway query |
| `resultType` | Normalized result type such as city, suburb, street, address, property, or listing |
| `title` | Homes.co.nz result title |
| `score` | Gateway relevance score when returned |
| `latitude` / `longitude` | Result coordinates |
| `city`, `suburb`, `street` | Address components |
| `streetNumber`, `unitIdentifier` | Address detail when available |
| `suburbId`, `cityId` | Homes.co.nz location IDs |
| `propertyId`, `listingId` | Public IDs when the gateway returns them |
| `size` | Area or result size value |
| `sourceUrl` | Homes.co.nz search URL for traceability |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Homes.co.nz property search data?

This actor uses pay-per-event pricing.

You pay a small start fee and a per-result charge for saved dataset rows.

The input prefill is intentionally small enough for a cheap first run.

Use `maxItems` to control spend for broad multi-city jobs.

### How to use Homes.co.nz Property Search Scraper

1. Open the actor on Apify.
2. Add one or more New Zealand search terms.
3. Choose `typeahead` for broad discovery or `address` for stricter address matching.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Input example

```json
{
  "searchTerms": [
    "auckland",
    "queen street auckland",
    "wellington",
    "christchurch",
    "hamilton"
  ],
  "maxItems": 100,
  "searchMode": "typeahead",
  "includeCentroid": false,
  "includeRawData": false
}
````

### Output example

```json
{
  "searchTerm": "auckland",
  "searchMode": "typeahead",
  "resultTypeCode": 1,
  "resultType": "city",
  "title": "Auckland",
  "score": 72.81268,
  "latitude": -36.84985594022932,
  "longitude": 174.76370664609487,
  "city": "Auckland",
  "suburb": null,
  "street": null,
  "streetNumber": 0,
  "suburbId": 0,
  "cityId": 8,
  "sourceUrl": "https://homes.co.nz/search/auckland",
  "scrapedAt": "2026-07-07T00:00:00.000Z"
}
```

### Search term tips

Use broad city terms for coverage.

Use suburb terms for local market lists.

Use street names plus a city for address candidate discovery.

Use exact full addresses when you want stricter matching.

Use multiple terms when you need more than the gateway returns for one term.

### Search modes

`typeahead` is best for broad public search discovery.

`address` is useful when you want address-focused candidates.

Both modes call public Homes.co.nz JSON endpoints.

### Centroid enrichment

Set `includeCentroid` to `true` to request centroid data for area and street results.

Centroid fields can help mapping workflows by adding a central coordinate and size estimate.

If Homes.co.nz does not return centroid data for a row, the actor keeps the row and leaves centroid fields empty.

### Raw data option

Set `includeRawData` to `true` when you want the original gateway object attached to every row.

This is useful for custom mapping, troubleshooting, or checking newly added upstream fields.

Leave it off for cleaner exports.

### Integrations

- 🧾 Export CSV rows into Google Sheets for lead review.
- 🗺️ Load coordinates into GIS tools for suburb and street mapping.
- 🧠 Send JSON to enrichment pipelines that normalize address candidates.
- 📈 Combine recurring runs with BI dashboards to monitor search coverage.
- 🔔 Use Apify webhooks to trigger downstream updates after each run.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/homes-co-nz-property-search-scraper').call({
  searchTerms: ['auckland', 'wellington'],
  maxItems: 100,
  searchMode: 'typeahead'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/homes-co-nz-property-search-scraper').call(run_input={
    'searchTerms': ['auckland', 'wellington'],
    'maxItems': 100,
    'searchMode': 'typeahead',
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~homes-co-nz-property-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["auckland","wellington"],"maxItems":100,"searchMode":"typeahead"}'
```

### MCP integration

Use the Apify MCP server with Claude Code, Claude Desktop, or other MCP-compatible clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/homes-co-nz-property-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-homes-co-nz https://mcp.apify.com/?tools=automation-lab/homes-co-nz-property-search-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-homes-co-nz": {
      "url": "https://mcp.apify.com/?tools=automation-lab/homes-co-nz-property-search-scraper"
    }
  }
}
```

Example prompts:

- "Run the Homes.co.nz property search scraper for Auckland and summarize the suburbs returned."
- "Extract Wellington street candidates and create a CSV-ready table."
- "Compare result counts for Auckland, Christchurch, and Hamilton."

### Data quality notes

Homes.co.nz controls the public gateway results.

Some fields are only returned for certain result types.

For example, a city result may have a city ID but no street number.

An address result may include street and number fields.

A listing or property result may include public IDs if Homes.co.nz exposes them.

### Troubleshooting

If you get no rows, try broader terms such as a city or suburb.

If results look too broad, switch from `typeahead` to `address` mode.

If you need more rows, add more search terms rather than only increasing `maxItems`.

If centroid fields are empty, the specific result probably does not support centroid lookup.

### Limits

The actor only extracts public search gateway data.

It does not access saved homes, favourites, private user accounts, admin routes, or logged-in endpoints.

It does not bypass paywalls or authentication.

### Legality

This actor is designed for public data access.

Always review Homes.co.nz terms and applicable New Zealand privacy and data protection rules before using output in production.

Do not use scraped data for spam, harassment, discrimination, or other unlawful activity.

### Related scrapers

Explore related Automation Lab actors for real estate and lead enrichment workflows:

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/realtor-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/idealista-scraper

### FAQ

#### Can I scrape exact Homes.co.nz addresses?

Yes. Add exact address terms and use `address` mode for stricter matching.

#### Can I scrape many New Zealand cities?

Yes. Add multiple city, suburb, or street terms and set `maxItems` high enough for your export.

#### Does this actor need a proxy?

No proxy is configured by default. The public gateway responded without proxy during development.

#### Does it scrape private Homes.co.nz account data?

No. The actor only calls public search and centroid endpoints.

#### Why are some IDs empty?

Homes.co.nz returns different fields for different result types. Empty IDs mean the gateway did not expose that ID for the row.

### Changelog

Initial version extracts public Homes.co.nz search candidates with optional centroid enrichment.

# Actor input Schema

## `searchTerms` (type: `array`):

Homes.co.nz search terms such as suburbs, cities, streets, or full addresses. Use multiple terms to collect more rows.

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

Optional Homes.co.nz search URLs. The actor extracts a search term from each URL path/query.

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

Maximum records to save across all search terms.

## `searchMode` (type: `string`):

Use typeahead for broad discovery or address for stricter address matching.

## `includeCentroid` (type: `boolean`):

Look up centroid coordinates and area size for area/street suggestions when Homes.co.nz returns them.

## `includeRawData` (type: `boolean`):

Attach the raw Homes.co.nz gateway object to each output row for debugging or custom mapping.

## Actor input object example

```json
{
  "searchTerms": [
    "auckland",
    "queen street auckland",
    "wellington",
    "christchurch",
    "hamilton"
  ],
  "startUrls": [
    {
      "url": "https://homes.co.nz/search/auckland"
    }
  ],
  "maxItems": 20,
  "searchMode": "typeahead",
  "includeCentroid": false,
  "includeRawData": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerms": [
        "auckland",
        "queen street auckland",
        "wellington",
        "christchurch",
        "hamilton"
    ],
    "startUrls": [
        {
            "url": "https://homes.co.nz/search/auckland"
        }
    ],
    "maxItems": 20,
    "searchMode": "typeahead",
    "includeCentroid": false,
    "includeRawData": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/homes-co-nz-property-search-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 = {
    "searchTerms": [
        "auckland",
        "queen street auckland",
        "wellington",
        "christchurch",
        "hamilton",
    ],
    "startUrls": [{ "url": "https://homes.co.nz/search/auckland" }],
    "maxItems": 20,
    "searchMode": "typeahead",
    "includeCentroid": False,
    "includeRawData": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/homes-co-nz-property-search-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 '{
  "searchTerms": [
    "auckland",
    "queen street auckland",
    "wellington",
    "christchurch",
    "hamilton"
  ],
  "startUrls": [
    {
      "url": "https://homes.co.nz/search/auckland"
    }
  ],
  "maxItems": 20,
  "searchMode": "typeahead",
  "includeCentroid": false,
  "includeRawData": false
}' |
apify call automation-lab/homes-co-nz-property-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Homes.co.nz Property Search Scraper",
        "description": "Extract Homes.co.nz address, suburb, street, and property search candidates for NZ real estate research, geocoding, and lead enrichment.",
        "version": "0.1",
        "x-build-id": "AVZSf0POIt9a38uEJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~homes-co-nz-property-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-homes-co-nz-property-search-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/automation-lab~homes-co-nz-property-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-homes-co-nz-property-search-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/automation-lab~homes-co-nz-property-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-homes-co-nz-property-search-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "🔎 Search terms",
                        "type": "array",
                        "description": "Homes.co.nz search terms such as suburbs, cities, streets, or full addresses. Use multiple terms to collect more rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Homes.co.nz search URLs",
                        "type": "array",
                        "description": "Optional Homes.co.nz search URLs. The actor extracts a search term from each URL path/query.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum property search results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum records to save across all search terms.",
                        "default": 20
                    },
                    "searchMode": {
                        "title": "Gateway search mode",
                        "enum": [
                            "typeahead",
                            "address"
                        ],
                        "type": "string",
                        "description": "Use typeahead for broad discovery or address for stricter address matching.",
                        "default": "typeahead"
                    },
                    "includeCentroid": {
                        "title": "Include centroid data",
                        "type": "boolean",
                        "description": "Look up centroid coordinates and area size for area/street suggestions when Homes.co.nz returns them.",
                        "default": false
                    },
                    "includeRawData": {
                        "title": "Include raw gateway JSON",
                        "type": "boolean",
                        "description": "Attach the raw Homes.co.nz gateway object to each output row for debugging or custom mapping.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```