# Realtor.ca Scraper — Canada Real Estate Agent Leads & Phones (`juramoshkov/realtor-ca-agent-scraper`) Actor

Realtor.ca scraper for Canadian real estate leads — listing agent phone, office, and brokerage plus full property data (price, beds, baths, taxes, MLS®). Search by city, postal code, MLS® number, or URL. Lead generation ready. No API key, no run-start fee.

- **URL**: https://apify.com/juramoshkov/realtor-ca-agent-scraper.md
- **Developed by:** [Jura Moshkov](https://apify.com/juramoshkov) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $45.00 / 1,000 enriched listings

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

<!--
MAINTAINER NOTE (not shown on the Apify Store page — HTML comments aren't rendered).
Shared RapidAPI-usage → Telegram reporter lives in @scrapers/core (packages/core/src/telegram-logger.ts).
Reuse it in this actor's src/main.ts exactly like realtor-property-agent:

  import { RapidApiUsageLogger } from "@scrapers/core";
  const usageStore = await Actor.openKeyValueStore("rapidapi-usage"); // NAMED store persists across runs
  const usage = new RapidApiUsageLogger({
    scraperName: "realtor-ca-agent",
    store: {
      load: async (key) => Number((await usageStore.getValue(key)) ?? 0),
      save: async (key, total) => { await usageStore.setValue(key, total); },
    },
  });
  await usage.init();
  // pass onRapidApiRequest: () => usage.record() into the client, then at run end:
  await usage.flush();

Env: set TELEGRAM_BOT_TOKEN in the actor's Apify env vars (.env is NOT deployed). Group/topic ids are
hardcoded in telegram-logger.ts. Every 10 RapidAPI requests it posts: "📊 realtor-ca-agent — N RapidAPI requests".
-->

## Realtor.ca Scraper — Canada Real Estate Agent Leads & Phones

**Realtor.ca scraper for Canadian real estate leads.** Extract Realtor.ca (MLS®) property listings **plus the listing agent's phone, office, brokerage, and email when available** in one enriched row per property — ready for real estate lead generation, agent prospecting, and CRM enrichment across Canada. Search by city, postal code, MLS® number, or a Realtor.ca URL. No browser automation, **no run-start fee**, and you pay only for successfully enriched results.

This Canadian real estate scraper turns Realtor.ca into a clean leads database: property data (price, beds, baths, taxes, MLS® number, photos) **and** contactable REALTORS® (agent phone, office, brokerage, email when available) in the same export — CSV, JSON, or Excel.

Looking for a **Realtor.ca agent leads scraper**, a **Canada MLS listing scraper**, or **REALTOR® phone numbers by city**? This actor does all three in one run.

### ✨ Why this Realtor.ca scraper

- 📇 **Agent contact in every row** — agent phone, office, brokerage, and email when available — not just property data.
- 🏠 **40+ property fields** — price, beds/baths, sqft, lot, year built, condo fees, taxes, MLS® number, days on market, photos, geo.
- 🔎 **4 input modes** — city/province search, postal-code search, MLS®-number enrichment, or paste a Realtor.ca URL.
- 🇨🇦 **Canada-wide** — every province and territory, English and French listings.
- 💸 **Pay only for results** — no run-start fee; charged per successfully enriched property.
- 📤 **CRM-ready export** — flat rows to CSV / JSON / Excel, or straight into your workflow via Apify integrations.

### Input modes

| Mode | Use it to | Requires |
|---|---|---|
| `citySearch` | Discover all listings + agents in a city/province (main mode) | `cities` |
| `postalSearch` | Discover listings + agents by postal code | `postalCodes` |
| `mlsNumbers` | Enrich a known list of MLS® numbers | `mlsNumbers` |
| `url` | Scrape any Realtor.ca search/listing URL you paste | `startUrls` |

### Use cases

- **Canadian real estate lead generation** — build lists of contactable REALTORS® by city, province, or postal code.
- **Agent prospecting & recruiting** — reach agents with their phone, office, brokerage, and live listing context.
- **Real estate market research** — price, location, property type, and days-on-market analysis across Canada.
- **CRM & spreadsheet enrichment** — push Realtor.ca property and agent data into your sales stack.

### Input

**Search by city** (main mode):

```json
{
  "mode": "citySearch",
  "cities": ["Toronto, ON"],
  "listingStatus": "forSale",
  "minPrice": 400000,
  "maxPrice": 1200000,
  "beds": 2,
  "maxResults": 100
}
````

**Enrich known MLS® numbers:**

```json
{
  "mode": "mlsNumbers",
  "mlsNumbers": ["W1234567", "C9876543"],
  "maxResults": 2
}
```

**Scrape a Realtor.ca URL:**

```json
{
  "mode": "url",
  "startUrls": ["https://www.realtor.ca/map#view=list&Sort=6-D&GeoIds=g30_dpz89rm7"],
  "listingStatus": "forSale",
  "maxResults": 100
}
```

### Output

One flat row per property. **Property fields:**

| Field | Type | Description |
|---|---|---|
| `mlsNumber` | string | MLS® listing number. |
| `url` | string | Listing URL on Realtor.ca. |
| `status` | string | Listing status (e.g. `for_sale`). |
| `price` | number | Listing price. |
| `currency` | string | Currency, usually CAD. |
| `beds` | number | Bedrooms. |
| `baths` | number | Bathrooms. |
| `sqft` | number | Interior square footage. |
| `lotSize` | string | Lot size when available. |
| `yearBuilt` | number | Year built. |
| `propertyType` | string | Property type (house, condo, etc.). |
| `streetAddress` / `city` / `province` / `postalCode` | string | Address parts. |
| `latitude` / `longitude` | number | Coordinates. |
| `condoFee` | number | Condo/maintenance fee when available. |
| `propertyTax` | number | Annual property tax when available. |
| `daysOnMarket` | number | Days on market. |
| `photoUrls` | array | Listing photo URLs. |
| `listedDate` | string | Listing date (ISO). |

**Agent / lead fields:**

| Field | Type | Description |
|---|---|---|
| `agentName` | string | Listing REALTOR® name. |
| `agentEmail` | string | Agent email when available. **Masked on the free tier.** |
| `agentEmailMasked` | boolean | Whether `agentEmail` is masked. |
| `agentPhone` | string | Agent office phone. |
| `agentCellPhone` | string | Agent cell phone. |
| `officeName` | string | Real estate office. |
| `brokerName` | string | Brokerage name. |
| `agentProfileUrl` | string | Agent profile URL. |

**Meta:** `mode`, `searchCity`, `sourceUrl`, `scrapedAt` (ISO), `error` (null on success).

### Pricing

**No run-start fee. You are charged only for successfully enriched properties.**

| Apify plan | Price per enriched property | Agent email when available |
|---|---|---|
| Free | $0.07 | Masked (`j***@e***.com`) |
| Bronze | $0.06 | Full |
| Silver | $0.05 | Full |
| Gold | $0.045 | Full |
| Platinum | $0.04 | Full |
| Diamond | $0.04 | Full |

Free runs are capped and mask the agent email when the source returns one. Phones, office, brokerage, and all property data are always returned. Upgrade your Apify plan for uncapped runs and full emails when available.

### FAQ

#### Does it include the REALTOR® email?

When Realtor.ca or the provider response includes an email, it is included in the enriched row. Free-tier runs mask the email (`j***@e***.com`); any paid Apify plan returns the full email. Many live Realtor.ca responses expose phone, office, brokerage, and an email contact reference rather than the raw email address.

#### How do I get Canadian real estate agent leads by city?

Use `citySearch` mode with one or more `cities`. Each search returns listings with the agent's name, phone, office, and brokerage attached.

#### Can I get REALTOR® contact details in bulk?

Yes. Run `citySearch` or `postalSearch` across multiple areas and export `agentPhone`, `agentCellPhone`, `officeName`, `brokerName`, and `agentEmail` when available to CSV or Google Sheets.

#### Do I need an API key?

No. Just set your input and run — the actor handles everything.

#### Is scraping Realtor.ca legal?

The actor returns publicly available listing data. You are responsible for using exported data in compliance with applicable laws (including Canadian privacy law such as PIPEDA and Canada's Anti-Spam Legislation / CASL), platform terms, MLS® rules, and outreach/marketing consent requirements.

### Coverage

Canada listings only (all provinces and territories).

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `cities` (type: `array`):

Canadian cities to search in citySearch mode. Use city plus province, e.g. Toronto, ON.

## `postalCodes` (type: `array`):

Canadian postal codes to search in postalSearch mode.

## `mlsNumbers` (type: `array`):

MLS listing numbers for mlsNumbers mode.

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

Realtor.ca search or listing URLs for url mode.

## `listingStatus` (type: `string`):

Which listings to return: for sale, for rent, or sold.

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

Max enriched properties per run. Each property costs ~1 upstream API request.

## `minPrice` (type: `integer`):

Only return listings priced at or above this amount (CAD).

## `maxPrice` (type: `integer`):

Only return listings priced at or below this amount (CAD).

## `beds` (type: `integer`):

Only return listings with at least this many bedrooms.

## `baths` (type: `integer`):

Only return listings with at least this many bathrooms.

## `requestDelayMs` (type: `integer`):

Delay in milliseconds between requests. Increase for very large runs.

## Actor input object example

```json
{
  "mode": "citySearch",
  "cities": [
    "Toronto, ON"
  ],
  "postalCodes": [
    "M5V"
  ],
  "listingStatus": "forSale",
  "maxResults": 5,
  "requestDelayMs": 400
}
```

# Actor output Schema

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

No description

## `resultsCsv` (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 = {
    "cities": [
        "Toronto, ON"
    ],
    "postalCodes": [
        "M5V"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("juramoshkov/realtor-ca-agent-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 = {
    "cities": ["Toronto, ON"],
    "postalCodes": ["M5V"],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("juramoshkov/realtor-ca-agent-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 '{
  "cities": [
    "Toronto, ON"
  ],
  "postalCodes": [
    "M5V"
  ],
  "maxResults": 5
}' |
apify call juramoshkov/realtor-ca-agent-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Realtor.ca Scraper — Canada Real Estate Agent Leads & Phones",
        "description": "Realtor.ca scraper for Canadian real estate leads — listing agent phone, office, and brokerage plus full property data (price, beds, baths, taxes, MLS®). Search by city, postal code, MLS® number, or URL. Lead generation ready. No API key, no run-start fee.",
        "version": "0.1",
        "x-build-id": "o4OS0skImt5BkK0Ks"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/juramoshkov~realtor-ca-agent-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-juramoshkov-realtor-ca-agent-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/juramoshkov~realtor-ca-agent-scraper/runs": {
            "post": {
                "operationId": "runs-sync-juramoshkov-realtor-ca-agent-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/juramoshkov~realtor-ca-agent-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-juramoshkov-realtor-ca-agent-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "citySearch",
                            "postalSearch",
                            "mlsNumbers",
                            "url"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "citySearch"
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Canadian cities to search in citySearch mode. Use city plus province, e.g. Toronto, ON.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postalCodes": {
                        "title": "Postal codes",
                        "type": "array",
                        "description": "Canadian postal codes to search in postalSearch mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mlsNumbers": {
                        "title": "MLS numbers",
                        "type": "array",
                        "description": "MLS listing numbers for mlsNumbers mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Realtor.ca URLs",
                        "type": "array",
                        "description": "Realtor.ca search or listing URLs for url mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingStatus": {
                        "title": "Listing status",
                        "enum": [
                            "forSale",
                            "forRent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which listings to return: for sale, for rent, or sold.",
                        "default": "forSale"
                    },
                    "maxResults": {
                        "title": "Max properties",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max enriched properties per run. Each property costs ~1 upstream API request.",
                        "default": 20
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount (CAD)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount (CAD)."
                    },
                    "beds": {
                        "title": "Min beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at least this many bedrooms."
                    },
                    "baths": {
                        "title": "Min baths",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at least this many bathrooms."
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay in milliseconds between requests. Increase for very large runs.",
                        "default": 400
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```