# Analyze Domains (`crawlerbros/analyze-domains`) Actor

Bulk-analyse a list of domains. Probes 4 URL variants (http/https, with/without www) and extracts title, meta description, Open Graph + Twitter Cards, emails, social handles, and tech stack. Optional toggles for SSL cert info, DNS records (A/AAAA/MX/TXT/NS), and WHOIS.

- **URL**: https://apify.com/crawlerbros/analyze-domains.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## Analyze Domains

Bulk-probe a list of domains and extract a structured profile for each — preferred URL, page title, meta description, contact emails, social-media handles, and a tech-stack fingerprint. HTTP-only, no proxy or browser required.

### What it does

You supply a list of domains (bare hostnames or full URLs); the actor:

1. Probes 4 URL variants per domain in parallel — `http://<d>`, `https://<d>`, `http://www.<d>`, `https://www.<d>`.
2. Picks the canonical "preferred" URL (first variant returning a 200 with HTML).
3. Extracts the landing page's title, meta description, canonical URL, Open Graph + Twitter Card metadata.
4. Optionally pulls contact emails, social-media handles (Twitter/X, Facebook, Instagram, LinkedIn, YouTube, TikTok, GitHub), and a tech-stack fingerprint (CMS, frameworks, analytics, CDN).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | array of strings (required) | `["apify.com"]` | List of domains. Accepts bare hostnames (`example.com`) or full URLs (`https://example.com/page?q=1`). |
| `extractContacts` | boolean | `true` | Pull `mailto:` links + plain-text email matches. Filters out boilerplate (`user@example.com`, `noreply@…`, etc). |
| `extractSocialLinks` | boolean | `true` | Detect handles for Twitter/X, Facebook, Instagram, LinkedIn, YouTube, TikTok, GitHub. |
| `extractTechStack` | boolean | `true` | Lightweight Wappalyzer-style scan — CMS, frameworks, analytics, CDN. |
| `extractSsl` | boolean | `false` | Probe each domain on port 443 and emit SSL cert info (issuer, subject, expiry, daysUntilExpiry). |
| `extractDns` | boolean | `false` | Resolve A / AAAA / MX / TXT / NS DNS records for each domain. |
| `extractWhois` | boolean | `false` | Query WHOIS over port 43 for registrar, creation/expiration/updated dates, name servers, status, abuse emails. |
| `concurrency` | integer | `5` (1–20) | How many domains to probe in parallel. Each probe issues up to 4 URL-variant requests in parallel. |

#### Example input

```json
{
  "domains": ["apify.com", "github.com", "vercel.com"],
  "extractContacts": true,
  "extractSocialLinks": true,
  "extractTechStack": true,
  "concurrency": 5
}
````

### Output

One record per input domain. Empty fields are omitted (no nulls).

```json
{
  "domain": "apify.com",
  "isReachable": true,
  "preferredUrl": "https://apify.com/",
  "title": "Apify: Full-stack web scraping and data extraction platform",
  "description": "Cloud platform for web scraping…",
  "canonical": "https://apify.com/",
  "ogTags": {
    "title": "Apify: Full-stack web scraping and data extraction platform",
    "type": "website",
    "url": "https://apify.com/",
    "image": "https://apify.com/og-image.jpg"
  },
  "emails": ["hello@apify.com", "support@apify.com"],
  "emailCount": 2,
  "socialLinks": {
    "twitter": "apify",
    "linkedin": "apify",
    "github": "apify",
    "youtube": "apify"
  },
  "socialLinkCount": 4,
  "techStack": ["Cloudflare", "Google Analytics", "Google Tag Manager", "Next.js", "React"],
  "ssl": {
    "issuer": "Let's Encrypt",
    "subject": "apify.com",
    "expires": "2027-01-15",
    "daysUntilExpiry": 270
  },
  "sslIsValid": true,
  "dns": {
    "A": ["104.21.x.x", "172.67.x.x"],
    "AAAA": ["2606:4700:..."],
    "MX": [{"preference": 10, "exchange": "mail.apify.com"}],
    "TXT": ["v=spf1 include:_spf.google.com ~all"],
    "NS": ["alma.ns.cloudflare.com", "lewis.ns.cloudflare.com"]
  },
  "whois": {
    "registrar": "GoDaddy.com, LLC",
    "creation_date": "2014-08-26",
    "expiration_date": "2027-08-26",
    "updated_date": "2024-07-29",
    "name_servers": ["alma.ns.cloudflare.com", "lewis.ns.cloudflare.com"],
    "status": ["clientTransferProhibited"],
    "emails": ["abuse@godaddy.com"]
  },
  "variantProbes": [
    {"url": "https://apify.com",     "status": 200, "contentType": "text/html", "bodyLen": 78213},
    {"url": "https://www.apify.com", "status": 301, "finalUrl": "https://apify.com/", "bodyLen": 0},
    {"url": "http://apify.com",      "status": 301, "finalUrl": "https://apify.com/", "bodyLen": 0},
    {"url": "http://www.apify.com",  "status": 301, "finalUrl": "https://apify.com/", "bodyLen": 0}
  ],
  "scrapedAt": "2026-04-26T14:23:11+00:00"
}
```

#### Output fields

- **`domain`** — normalised hostname (scheme/path/port/www stripped).
- **`isReachable`** — `true` if at least one of the 4 URL variants returned with a parseable response.
- **`preferredUrl`** — the canonical landing URL (first 200-with-HTML variant; final URL after redirects when applicable).
- **`title`** / **`description`** — `<title>` and `<meta name="description">` of the landing page.
- **`canonical`** — `<link rel="canonical">` href when present.
- **`ogTags`** — flat map of `og:*` properties (`title`, `type`, `url`, `image`, `description`, `site_name`, …).
- **`emails`** / **`emailCount`** — deduped contact emails, lowercase placeholders (`user@example.com`, `noreply@…`) filtered out.
- **`socialLinks`** / **`socialLinkCount`** — `{platform: handle}` map.
- **`techStack`** — array of detected technologies (CMS, frameworks, analytics, CDN).
- **`ssl`** — (when `extractSsl: true`) `issuer`, `subject`, `expires` (YYYY-MM-DD), `daysUntilExpiry`. `error` key on lookup failure.
- **`sslIsValid`** — derived boolean: `true` when SSL fetch succeeded AND not expired.
- **`dns`** — (when `extractDns: true`) record types as keys: `A`, `AAAA`, `NS`, `TXT` are arrays of strings; `MX` is an array of `{preference, exchange}` objects.
- **`whois`** — (when `extractWhois: true`) parsed registrar, dates, name servers, status flags, abuse emails. `error` key on lookup failure.
- **`variantProbes`** — per-variant status report (`url`, `status`, optional `finalUrl`, `contentType`, `bodyLen`, `errorReason`).
- **`scrapedAt`** — ISO-8601 UTC timestamp.

### Use cases

- **Lead enrichment** — turn a list of company domains into a profile with contact emails + social handles in one pass.
- **Domain audits** — detect which domains redirect to `https://www.`, which are unreachable, which still serve plain HTTP.
- **Tech-stack survey** — find every Shopify / WordPress / Next.js site in a list.
- **Competitive research** — pull title + description + tech-stack for every competitor in a market.
- **Migration planning** — confirm new domains have correct canonical + redirects in place after a launch.

### FAQ

**Does it need a proxy?**
No. The actor uses Chrome 131 TLS-fingerprint impersonation; almost all marketing / corporate sites accept the request straight from datacenter IPs. Aggressively bot-protected targets (e.g. Cloudflare with bot-fight on hard mode) may return a challenge — those domains will simply be marked `isReachable: false` rather than proxied.

**What about cookies / login?**
None needed — only the public landing page is fetched.

**How are invalid domains handled?**
Each invalid input emits a separate record of shape `{type: "analyze_domains_error", reason: "invalid_domain", input: ..., scrapedAt: ...}` so the dataset audit stays honest. The valid domains in the same run are still processed.

**Why are some fields missing on a record?**
The actor follows an omit-empty contract: fields not populated on the source page (e.g. no `og:image`, no `description`) are simply absent — no nulls.

**How many domains can it handle?**
There is no hard cap; the `concurrency` setting controls parallelism (1–20). At `concurrency: 5`, roughly 100 domains complete in under 90 seconds.

**Can I extract internal pages too?**
This actor focuses on the landing page only. For sitemap-walking and per-page metadata at scale, see SiteResearcher.

**What counts as a "tech stack" match?**
Body-content + response-header signatures (e.g. `wp-content/`, `_next/static/`, `cf-ray` header). It's a fast best-effort fingerprint, not a Wappalyzer-class deep scan.

# Actor input Schema

## `domains` (type: `array`):

List of domains to analyse. Accepts bare hostnames (`example.com`) or full URLs (`https://example.com/path`); the actor extracts the registrable domain.

## `extractContacts` (type: `boolean`):

Scan the landing-page HTML for `mailto:` links and email-pattern matches. Filters out boilerplate placeholder addresses.

## `extractSocialLinks` (type: `boolean`):

Pull links to Twitter/X, Facebook, Instagram, LinkedIn, YouTube, TikTok, GitHub from the landing page.

## `extractTechStack` (type: `boolean`):

Run a lightweight Wappalyzer-style scan against the landing-page HTML and headers.

## `extractSsl` (type: `boolean`):

Probe each domain on port 443 and emit SSL cert details (issuer, subject, expiry, daysUntilExpiry).

## `extractDns` (type: `boolean`):

Resolve A / AAAA / MX / TXT / NS DNS records for each domain. Adds a `dns` block to each output record with the resolved values.

## `extractWhois` (type: `boolean`):

Query WHOIS over port 43 for registrar, creation/expiration/updated dates, name servers, status flags, and abuse contacts. Adds a `whois` block to each output record.

## `concurrency` (type: `integer`):

How many domains to probe in parallel. Each probe issues up to 4 URL-variant requests.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "extractContacts": true,
  "extractSocialLinks": true,
  "extractTechStack": true,
  "extractSsl": false,
  "extractDns": false,
  "extractWhois": false,
  "concurrency": 5
}
```

# 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 = {
    "domains": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/analyze-domains").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 = { "domains": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/analyze-domains").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 '{
  "domains": [
    "apify.com"
  ]
}' |
apify call crawlerbros/analyze-domains --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Analyze Domains",
        "description": "Bulk-analyse a list of domains. Probes 4 URL variants (http/https, with/without www) and extracts title, meta description, Open Graph + Twitter Cards, emails, social handles, and tech stack. Optional toggles for SSL cert info, DNS records (A/AAAA/MX/TXT/NS), and WHOIS.",
        "version": "0.1",
        "x-build-id": "W3sRrZ9y8h74sw4c6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~analyze-domains/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-analyze-domains",
                "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/crawlerbros~analyze-domains/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-analyze-domains",
                "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/crawlerbros~analyze-domains/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-analyze-domains",
                "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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "List of domains to analyse. Accepts bare hostnames (`example.com`) or full URLs (`https://example.com/path`); the actor extracts the registrable domain.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extractContacts": {
                        "title": "Extract contact emails",
                        "type": "boolean",
                        "description": "Scan the landing-page HTML for `mailto:` links and email-pattern matches. Filters out boilerplate placeholder addresses.",
                        "default": true
                    },
                    "extractSocialLinks": {
                        "title": "Extract social-media handles",
                        "type": "boolean",
                        "description": "Pull links to Twitter/X, Facebook, Instagram, LinkedIn, YouTube, TikTok, GitHub from the landing page.",
                        "default": true
                    },
                    "extractTechStack": {
                        "title": "Detect tech stack",
                        "type": "boolean",
                        "description": "Run a lightweight Wappalyzer-style scan against the landing-page HTML and headers.",
                        "default": true
                    },
                    "extractSsl": {
                        "title": "Extract SSL certificate info",
                        "type": "boolean",
                        "description": "Probe each domain on port 443 and emit SSL cert details (issuer, subject, expiry, daysUntilExpiry).",
                        "default": false
                    },
                    "extractDns": {
                        "title": "Extract DNS records",
                        "type": "boolean",
                        "description": "Resolve A / AAAA / MX / TXT / NS DNS records for each domain. Adds a `dns` block to each output record with the resolved values.",
                        "default": false
                    },
                    "extractWhois": {
                        "title": "Extract WHOIS info",
                        "type": "boolean",
                        "description": "Query WHOIS over port 43 for registrar, creation/expiration/updated dates, name servers, status flags, and abuse contacts. Adds a `whois` block to each output record.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrent domain probes",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many domains to probe in parallel. Each probe issues up to 4 URL-variant requests.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```