# Dental Clinic Lead Finder (`automation-lab/dental-clinic-lead-finder`) Actor

Find dental clinic leads from Google Maps with phone, website, ratings, reviews, address, and public email enrichment.

- **URL**: https://apify.com/automation-lab/dental-clinic-lead-finder.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## Dental Clinic Lead Finder

Find dental clinic leads from Google Maps and enrich clinic websites with public email addresses.

Dental Clinic Lead Finder is built for people who need a clean, exportable list of dental practices in a city, region, or niche. Enter one or more dental search terms, add locations, and the actor collects business details from Google Maps plus optional email addresses from public clinic websites.

### What does Dental Clinic Lead Finder do?

This actor searches Google Maps for dental businesses and saves one dataset row per clinic.

It can collect:

- 🦷 Clinic name
- 📍 Address
- ☎️ Phone number
- 🌐 Website URL
- ⭐ Rating and review count
- 🗺️ Google Maps URL
- 📧 Public email addresses found on the clinic website
- 🔎 Search query and location used to find the lead
- 🧭 Latitude, longitude, and place ID when available

### Who is it for?

Dental Clinic Lead Finder is useful for:

- 🧑‍💼 Dental suppliers building prospect lists for outreach
- 📣 Local SEO agencies prospecting dental practices
- 🧾 Lead generation agencies creating regional clinic databases
- 🧑‍⚕️ Recruiters looking for dental offices and DSOs
- 🛠️ SaaS teams selling tools to dental practices
- 📊 Analysts mapping dental market coverage by city

### Why use this actor?

Google Maps has rich public information, but manually copying dental clinic details is slow. This actor automates the repetitive discovery step and returns structured rows that can be exported to CSV, Excel, Google Sheets, or your CRM.

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Dental clinic or dentist business name |
| `category` | Google Maps business category when available |
| `address` | Public business address |
| `phone` | Public phone number |
| `website` | Clinic website URL |
| `emails` | Public emails found on the website/contact pages |
| `rating` | Google Maps star rating |
| `reviewCount` | Number of reviews |
| `googleMapsUrl` | Source Google Maps place URL |
| `sourceUrl` | Alias of the source Google Maps place URL for lead workflows |
| `placeId` | Google place identifier parsed from the URL when available |
| `latitude` | Latitude parsed from Maps URL when available |
| `longitude` | Longitude parsed from Maps URL when available |
| `searchQuery` | Dental term used for discovery |
| `location` | Location used for discovery |
| `openingHours` | Visible hours text when available |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to find dental clinic leads?

The actor uses pay-per-event pricing. You pay a small start fee and then a per-lead fee for saved dental clinic rows. Exact prices are shown on the Apify actor page before you run it.

To keep first runs affordable, the default input asks for a small number of leads. Increase `maxLeads` when you are ready to build a larger prospect list.

### How to use Dental Clinic Lead Finder

1. Open the actor on Apify.
2. Enter dental search terms such as `dental clinic`, `dentist`, `orthodontist`, or `emergency dentist`.
3. Add one or more locations such as `Austin, TX` or `Brooklyn, NY`.
4. Choose the maximum number of leads.
5. Keep email enrichment enabled if you want the actor to inspect clinic websites.
6. Run the actor.
7. Export the dataset to CSV, Excel, JSON, or connect it to your workflow.

### Input example

```json
{
  "searchQueries": ["dental clinic", "dentist"],
  "locations": ["Austin, TX"],
  "maxLeads": 20,
  "enrichEmails": true,
  "maxWebsitePagesPerClinic": 2,
  "language": "en",
  "countryCode": "us",
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Input fields

#### `searchQueries`

Dental business types to search for. Examples:

- `dental clinic`
- `dentist`
- `cosmetic dentist`
- `orthodontist`
- `emergency dentist`

#### `locations`

Cities, regions, neighborhoods, or postal areas. Each search term is combined with each location.

#### `maxLeads`

Maximum number of dental clinic leads saved across the whole run.

#### `enrichEmails`

When enabled, the actor visits clinic websites and a small number of public contact/about pages to find email addresses.

#### `maxWebsitePagesPerClinic`

Controls email enrichment cost. The default checks up to 2 pages per clinic.

#### `proxyConfiguration`

Leave the proxy disabled for small tests. If Google limits the runtime IP, enable Apify Proxy in the input.

### Output example

```json
{
  "searchQuery": "dental clinic",
  "location": "Austin, TX",
  "name": "Example Dental Care",
  "category": "Dental clinic",
  "address": "123 Main St, Austin, TX",
  "phone": "+1 512-555-0100",
  "website": "https://exampledental.com/",
  "emails": ["info@exampledental.com"],
  "rating": 4.8,
  "reviewCount": 312,
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "sourceUrl": "https://www.google.com/maps/place/...",
  "placeId": "0x...",
  "latitude": 30.2672,
  "longitude": -97.7431,
  "claimed": null,
  "openingHours": "Open ⋅ Closes 5 PM",
  "source": "google_maps",
  "scrapedAt": "2026-05-29T08:00:00.000Z"
}
```

### Tips for better lead lists

- Use specific dental terms for niche campaigns.
- Search one metro area at a time for easier deduplication.
- Keep `maxWebsitePagesPerClinic` low when testing.
- Export results to CSV and remove duplicates by website or phone number.
- Try nearby suburbs if a city returns fewer clinics than expected.

### Email enrichment notes

Email extraction is best-effort. The actor only reads public pages on clinic websites. Some clinics use contact forms instead of publishing email addresses. In those cases, the `emails` array can be empty while the lead is still useful because phone, website, and Maps data are present.

### Integrations

You can connect the dataset to:

- Google Sheets for prospect review
- HubSpot or Salesforce through Make/Zapier
- Clay enrichment tables
- Airtable lead databases
- Apify webhooks for automated delivery
- Your own API pipeline using Apify Client

### 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/dental-clinic-lead-finder').call({
  searchQueries: ['dental clinic'],
  locations: ['Austin, TX'],
  maxLeads: 20,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/dental-clinic-lead-finder').call(run_input={
    'searchQueries': ['dental clinic'],
    'locations': ['Austin, TX'],
    'maxLeads': 20,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~dental-clinic-lead-finder/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["dental clinic"],"locations":["Austin, TX"],"maxLeads":20}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/dental-clinic-lead-finder
```

Claude Code setup:

```bash
claude mcp add apify-dental-leads https://mcp.apify.com/?tools=automation-lab/dental-clinic-lead-finder
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-dental-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/dental-clinic-lead-finder"
    }
  }
}
```

Example prompts:

- “Find 50 dental clinics in Austin and summarize those with emails.”
- “Create a CSV-ready list of orthodontists in Denver.”
- “Find dental clinics in Brooklyn and group them by rating.”

### Legality and responsible use

This actor collects publicly visible business information. You are responsible for using exported data lawfully, respecting privacy rules, and following applicable outreach regulations such as CAN-SPAM, GDPR, and local telemarketing rules.

### FAQ

#### Why did I get fewer leads than requested?

Google Maps may show fewer available businesses for a specific query/location, or it may temporarily limit scrolling. Try a broader term or nearby location.

#### Why are emails missing?

Many dental clinics do not publish email addresses. They may use contact forms, booking widgets, or phone-only workflows.

#### Should I enable a proxy?

Start without a proxy for small tests. If Google blocks the runtime IP or returns empty pages, enable Apify Proxy in the input.

### Related scrapers

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/google-maps-reviews-scraper

### Changelog

#### 0.1

Initial version for Google Maps dental clinic lead discovery with optional website email enrichment.

# Actor input Schema

## `searchQueries` (type: `array`):

Dental business types to search for on Google Maps.

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

Cities, regions, or ZIP/postal areas to combine with each search term.

## `maxLeads` (type: `integer`):

Total number of clinic leads to save across all searches.

## `enrichEmails` (type: `boolean`):

Visit each clinic website and public contact/about pages to extract email addresses. Turn on for email enrichment; leave off for faster Google Maps lead collection.

## `maxWebsitePagesPerClinic` (type: `integer`):

Maximum public website pages to check for emails per clinic.

## `language` (type: `string`):

Language code used for Google Maps UI and results.

## `countryCode` (type: `string`):

Country code used for localized Google Maps results.

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

Optional proxy settings. Leave empty to use the runtime IP; add Apify Proxy if Google limits requests.

## Actor input object example

```json
{
  "searchQueries": [
    "dental clinic",
    "dentist"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxLeads": 20,
  "enrichEmails": false,
  "maxWebsitePagesPerClinic": 2,
  "language": "en",
  "countryCode": "us",
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "searchQueries": [
        "dental clinic",
        "dentist"
    ],
    "locations": [
        "Austin, TX"
    ],
    "language": "en",
    "countryCode": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dental-clinic-lead-finder").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 = {
    "searchQueries": [
        "dental clinic",
        "dentist",
    ],
    "locations": ["Austin, TX"],
    "language": "en",
    "countryCode": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dental-clinic-lead-finder").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 '{
  "searchQueries": [
    "dental clinic",
    "dentist"
  ],
  "locations": [
    "Austin, TX"
  ],
  "language": "en",
  "countryCode": "us"
}' |
apify call automation-lab/dental-clinic-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/dental-clinic-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dental Clinic Lead Finder",
        "description": "Find dental clinic leads from Google Maps with phone, website, ratings, reviews, address, and public email enrichment.",
        "version": "0.1",
        "x-build-id": "Uy6w32V5UrdBg4hWk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~dental-clinic-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-dental-clinic-lead-finder",
                "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~dental-clinic-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-dental-clinic-lead-finder",
                "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~dental-clinic-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-dental-clinic-lead-finder",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Dental search terms",
                        "type": "array",
                        "description": "Dental business types to search for on Google Maps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or ZIP/postal areas to combine with each search term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxLeads": {
                        "title": "Maximum dental clinic leads",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Total number of clinic leads to save across all searches.",
                        "default": 20
                    },
                    "enrichEmails": {
                        "title": "Find emails on clinic websites",
                        "type": "boolean",
                        "description": "Visit each clinic website and public contact/about pages to extract email addresses. Turn on for email enrichment; leave off for faster Google Maps lead collection.",
                        "default": false
                    },
                    "maxWebsitePagesPerClinic": {
                        "title": "Website pages per clinic",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum public website pages to check for emails per clinic.",
                        "default": 2
                    },
                    "language": {
                        "title": "Google Maps language",
                        "type": "string",
                        "description": "Language code used for Google Maps UI and results.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Google country code",
                        "type": "string",
                        "description": "Country code used for localized Google Maps results.",
                        "default": "us"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave empty to use the runtime IP; add Apify Proxy if Google limits requests.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```