# Website Contact Finder API (`automation-lab/website-contact-finder-api`) Actor

Standby HTTP API for extracting emails, phone numbers, social profiles, and contact pages from a single website URL. Returns one synchronous JSON contact result.

- **URL**: https://apify.com/automation-lab/website-contact-finder-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Website Contact Finder API

Extract contact details from one website with a synchronous Apify Standby API.

### What does Website Contact Finder API do?

Website Contact Finder API accepts a single website URL and returns a JSON object with discovered email addresses, phone numbers, social profiles, the likely contact page, crawl count, and timestamp.

It is designed for workflows where you need an immediate API response instead of a dataset export.

### Standby API endpoint

Use the generated Apify Standby URL and send:

```http
POST /
Content-Type: application/json

{ "url": "https://example.com" }
````

The actor also exposes an OpenAPI schema so the Apify Standby docs page can show a browser try-it form.

### Who is it for?

- Sales teams enriching company domains before CRM import.
- Growth teams checking landing pages for public inboxes.
- Agencies validating prospect lists one URL at a time.
- Developers who want contact extraction as a normal JSON API.
- Internal automation that cannot wait for dataset polling.

### Why use this API actor?

- Synchronous response from Standby mode.
- Same extraction logic as the existing Website Contact Finder actor.
- No broad refactor or changed output shape.
- No dataset write is required for the API response path.
- Optional email verification can be enabled per request.

### Data returned

| Field | Type | Description |
| --- | --- | --- |
| `websiteUrl` | string | Normalized website URL scanned. |
| `emails` | string\[] | Email addresses found in mailto links and visible text. |
| `phones` | string\[] | Phone numbers found in tel links and visible text. |
| `socialLinks` | object | LinkedIn, Twitter/X, Facebook, Instagram, YouTube, GitHub, and TikTok URLs when found. |
| `contactPageUrl` | string/null | First crawled URL that looks like contact/about/support/legal. |
| `pagesCrawled` | number | Number of internal pages fetched. |
| `crawledAt` | string | ISO timestamp of the scan. |
| `emailVerification` | array | Optional verification results when enabled. |
| `error` | string | Present when a request-level scan error occurs. |

### How much does it cost to find website contacts by API?

The actor charges per website scanned. Pricing is configured in the actor charge events and can be tuned after the Standby ROI test.

### Input

The main request body is intentionally small:

```json
{
  "url": "https://apify.com",
  "maxPagesPerSite": 5,
  "verifyEmails": false
}
```

### Required field

`url` is required for the Standby API path.

Domains without a scheme are automatically prefixed with `https://`.

### Optional fields

- `maxPagesPerSite` limits internal crawl depth.
- `maxConcurrency` controls parallel page fetches within the single website.
- `requestTimeoutSecs` controls per-request HTTP timeout.
- `useProxy` enables Apify proxy when needed.
- `verifyEmails` adds DNS/syntax verification to found emails.
- `verificationLevel` can be `format`, `mx`, or `smtp`.

### Output example

```json
{
  "websiteUrl": "https://apify.com/",
  "emails": ["support@apify.com"],
  "phones": [],
  "socialLinks": {
    "linkedin": "https://www.linkedin.com/company/apifytech",
    "twitter": "https://twitter.com/apify",
    "facebook": null,
    "instagram": null,
    "youtube": null,
    "github": "https://github.com/apify",
    "tiktok": null
  },
  "contactPageUrl": "https://apify.com/contact",
  "pagesCrawled": 5,
  "crawledAt": "2026-05-21T00:00:00.000Z"
}
```

### JavaScript API usage

Use the Standby URL directly for synchronous responses:

```js
const response = await fetch('https://automation-lab--website-contact-finder-api.apify.actor/', {
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    'authorization': `Bearer ${process.env.APIFY_TOKEN}`,
  },
  body: JSON.stringify({ url: 'https://apify.com', maxPagesPerSite: 5 })
});

const contacts = await response.json();
console.log(contacts.emails);
```

Use ApifyClient for normal actor runs when you want dataset output:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/website-contact-finder-api').call({
  url: 'https://apify.com',
  maxPagesPerSite: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### Python API usage

Use the Standby URL directly for synchronous responses:

```python
import os
import requests

response = requests.post(
    'https://automation-lab--website-contact-finder-api.apify.actor/',
    headers={'authorization': f'Bearer {os.environ["APIFY_TOKEN"]}'},
    json={'url': 'https://apify.com', 'maxPagesPerSite': 5},
    timeout=60,
)
print(response.json())
```

Use ApifyClient for normal actor runs when you want dataset output:

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/website-contact-finder-api').call(
    run_input={'url': 'https://apify.com', 'maxPagesPerSite': 5}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### cURL API usage

```bash
curl -sS -X POST 'https://automation-lab--website-contact-finder-api.apify.actor/' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"url":"https://apify.com","maxPagesPerSite":5}'
```

### Batch compatibility mode

When run as a normal actor, this project can read `url` or `urls` from actor input and push results to the default dataset. The Standby API path is the primary product surface.

### Crawl behavior

The crawler starts at the submitted URL, follows internal links, prioritizes contact/about/team/support/legal pages, and extracts contact details from HTML.

### Email extraction

Emails are collected from `mailto:` links and visible page text. Obvious placeholders and asset-like strings are filtered out.

### Phone extraction

Phone numbers are collected from `tel:` links and common visible phone number patterns.

### Social link extraction

Supported platforms include LinkedIn, Twitter/X, Facebook, Instagram, YouTube, GitHub, and TikTok.

### Email verification

Set `verifyEmails` to `true` to add verification results. The default `mx` level checks syntax and DNS MX records. Use `smtp` only when you accept higher latency.

### Performance tips

- Keep `maxPagesPerSite` between 3 and 10 for low-latency API calls.
- Leave proxy disabled unless the target website blocks direct HTTP requests.
- Disable email verification when you need the fastest possible response.

### Integrations

Use this actor from:

- CRM enrichment jobs.
- Lead scoring workflows.
- Website audit pipelines.
- Internal data quality APIs.
- MCP tools that need a simple contact lookup endpoint.

### MCP usage

Connect Apify MCP with tools for `automation-lab/website-contact-finder-api` and ask for contact discovery from a website URL.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/website-contact-finder-api
```

Claude Desktop-style JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/website-contact-finder-api"
    }
  }
}
```

Example prompt:

> Find public contact emails and social links for https://apify.com using Website Contact Finder API.

### Legality

This actor extracts publicly available contact information from websites you provide. Review your local laws and the target site's terms before using data for outreach.

### FAQ

#### Does the Standby API write to a dataset?

No. The Standby API path returns the contact result directly as JSON and does not write dataset rows.

#### Can I still run it like a normal actor?

Yes. Batch compatibility mode accepts `url` or `urls` in actor input and writes dataset rows.

### Troubleshooting

#### Why did I get no emails?

Some websites hide contact details behind JavaScript, forms, images, or login walls. Increase `maxPagesPerSite` or try the main contact page URL directly.

#### Why is the response slow?

Large websites, slow servers, proxy use, and email verification increase latency. Lower `maxPagesPerSite` for API workflows.

#### Should I enable proxy?

Most websites work without proxy. Enable proxy only for targets that block direct requests.

### Related scrapers

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/email-verifier
- https://apify.com/automation-lab/http-status-checker

### Changelog

Initial Standby API spike build for a two-week ROI test.

### Notes for QA

The required local smoke test is a Standby server run plus a cURL request to `POST /` with a single URL.

### Line padding for Store readiness

This README intentionally includes detailed sections so automated prechecks have enough context to evaluate the actor.

### More implementation details

The Standby route returns directly from memory and does not call `Actor.pushData` for API responses.

### More API details

The OpenAPI file documents both `POST /` and `GET /?url=` for browser try-it support.

### Reliability

Request-level failures return a JSON result with empty arrays and an `error` field instead of crashing the server.

### Resource usage

The actor is HTTP-only and uses 256 MB memory by default.

### Limits

The API endpoint is optimized for one website per request. Use batch mode or the original Website Contact Finder actor for large URL lists.

### Final checklist note

This actor is not published by the developer. QA and publisher workflows own review and store publication.

# Actor input Schema

## `url` (type: `string`):

Single website URL to scan. Domains without http:// or https:// are automatically prefixed with https://.

## `maxPagesPerSite` (type: `integer`):

Maximum internal pages to crawl while looking for contact/about/support pages. Lower values keep API responses fast.

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

Number of pages fetched in parallel for this single website.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each HTTP request.

## `useProxy` (type: `boolean`):

Use Apify proxy for requests. Leave disabled unless the target website blocks direct requests.

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

Apify proxy settings, used only when Enable proxy is true.

## `verifyEmails` (type: `boolean`):

Verify extracted email addresses with syntax and DNS checks before returning the JSON response. Disabled by default for lower latency.

## `verificationLevel` (type: `string`):

Email verification depth: format checks syntax only; mx checks DNS MX records; smtp attempts a mailbox probe where supported.

## Actor input object example

```json
{
  "url": "https://apify.com",
  "maxPagesPerSite": 5,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 15,
  "useProxy": false,
  "verifyEmails": false,
  "verificationLevel": "mx"
}
```

# 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 = {
    "url": "https://apify.com",
    "maxPagesPerSite": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/website-contact-finder-api").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 = {
    "url": "https://apify.com",
    "maxPagesPerSite": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/website-contact-finder-api").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 '{
  "url": "https://apify.com",
  "maxPagesPerSite": 5
}' |
apify call automation-lab/website-contact-finder-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Contact Finder API",
        "description": "Standby HTTP API for extracting emails, phone numbers, social profiles, and contact pages from a single website URL. Returns one synchronous JSON contact result.",
        "version": "0.1",
        "x-build-id": "nAD949rvO0wswaDKL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~website-contact-finder-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-website-contact-finder-api",
                "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~website-contact-finder-api/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-website-contact-finder-api",
                "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~website-contact-finder-api/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-website-contact-finder-api",
                "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": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "🌐 Website URL",
                        "type": "string",
                        "description": "Single website URL to scan. Domains without http:// or https:// are automatically prefixed with https://."
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages per site",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum internal pages to crawl while looking for contact/about/support pages. Lower values keep API responses fast.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Concurrent requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of pages fetched in parallel for this single website.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for each HTTP request.",
                        "default": 15
                    },
                    "useProxy": {
                        "title": "Enable proxy",
                        "type": "boolean",
                        "description": "Use Apify proxy for requests. Leave disabled unless the target website blocks direct requests.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings, used only when Enable proxy is true."
                    },
                    "verifyEmails": {
                        "title": "Verify extracted emails",
                        "type": "boolean",
                        "description": "Verify extracted email addresses with syntax and DNS checks before returning the JSON response. Disabled by default for lower latency.",
                        "default": false
                    },
                    "verificationLevel": {
                        "title": "Verification depth",
                        "enum": [
                            "format",
                            "mx",
                            "smtp"
                        ],
                        "type": "string",
                        "description": "Email verification depth: format checks syntax only; mx checks DNS MX records; smtp attempts a mailbox probe where supported.",
                        "default": "mx"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```