# Website Contact Extractor (`mighty_monk/website-contact-extractor`) Actor

Extract contact information (emails, phone numbers, social profiles, addresses) from websites by crawling homepage, contact, about, and footer links. One structured result per domain with CSV and Markdown export.

- **URL**: https://apify.com/mighty\_monk/website-contact-extractor.md
- **Developed by:** [Harsh](https://apify.com/mighty_monk) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 domain contacts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Extractor

**Extract emails, phone numbers, social profiles, and addresses from one or more websites.**

Website Contact Extractor is an Apify Actor built with **TypeScript** and **Crawlee CheerioCrawler**. Point it at company homepages — it crawls the landing page plus contact/about/footer links, deduplicates contacts per domain, and writes a structured dataset plus CSV and Markdown summaries.

### Features

- **Email extraction** — `mailto:` links, page text regex, schema.org; filters noise (`example.com`, Sentry, Wixpress, noreply, image extensions)
- **Phone extraction** — `tel:` links, international patterns, `itemprop="telephone"`
- **Social profiles** — LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok, GitHub
- **Physical addresses** — schema.org `PostalAddress`, microdata, footer `<address>` blocks
- **Contact page discovery** — follows contact, about, team, support, locations, impressum links
- **Company name** — from `og:site_name`, page title, or JSON-LD Organization
- **Per-domain deduplication** — one dataset item per domain with merged contacts
- **Rate limiting & retries** — configurable concurrency, delay, and request retries
- **Proxy-ready** — optional Apify Proxy configuration
- **Exports** — `CONTACTS.csv` and `CONTACTS.md` in the default key-value store

### Installation

```bash
## Clone / open the Actor directory
cd website-contact-extractor

## Install dependencies
npm install

## Run locally (uses storage/key_value_stores/default/INPUT.json or --input)
apify run
````

On the Apify platform, deploy with `apify push` or use the published Actor from the Store.

### Input

| Field                | Type       | Required | Default   | Description                            |
| -------------------- | ---------- | -------- | --------- | -------------------------------------- |
| `startUrls`          | `object[]` | Yes      | —         | Homepage URLs to extract contacts from |
| `maxPagesPerDomain`  | `integer`  | No       | `10`      | Max pages crawled per domain           |
| `maxConcurrency`     | `integer`  | No       | `5`       | Parallel request limit                 |
| `maxRequestRetries`  | `integer`  | No       | `3`       | Retries for failed requests            |
| `requestDelayMs`     | `integer`  | No       | `200`     | Delay hint for rate limiting           |
| `followContactLinks` | `boolean`  | No       | `true`    | Crawl discovered contact/about links   |
| `includeEmails`      | `boolean`  | No       | `true`    | Extract emails                         |
| `includePhones`      | `boolean`  | No       | `true`    | Extract phones                         |
| `includeSocials`     | `boolean`  | No       | `true`    | Extract social profiles                |
| `includeAddresses`   | `boolean`  | No       | `true`    | Extract physical addresses             |
| `proxyConfiguration` | `object`   | No       | Proxy off | Apify Proxy settings                   |

#### Example input

```json
{
    "startUrls": [
        { "url": "https://www.apify.com" },
        { "url": "https://www.shopify.com" },
        { "url": "https://stripe.com" }
    ],
    "maxPagesPerDomain": 5,
    "maxConcurrency": 5,
    "requestDelayMs": 200,
    "followContactLinks": true,
    "includeEmails": true,
    "includePhones": true,
    "includeSocials": true,
    "includeAddresses": true
}
```

See also: [`examples/input.json`](examples/input.json)

### Output

Each dataset item is one domain:

| Field             | Type             | Description                           |
| ----------------- | ---------------- | ------------------------------------- |
| `domain`          | `string`         | Normalized host without `www`         |
| `url`             | `string`         | Start URL for the domain              |
| `companyName`     | `string \| null` | Detected company/site name            |
| `emails`          | `string[]`       | Deduplicated emails                   |
| `phones`          | `string[]`       | Deduplicated phones                   |
| `socials`         | `object`         | Map of platform → profile URL         |
| `addresses`       | `string[]`       | Physical addresses when found         |
| `contactPageUrls` | `string[]`       | Discovered contact/about URLs         |
| `pagesScraped`    | `integer`        | Pages successfully scraped            |
| `scrapedAt`       | `string`         | ISO timestamp                         |
| `error`           | `string \| null` | Present if the domain failed entirely |

#### Example output

```json
{
    "domain": "apify.com",
    "url": "https://www.apify.com",
    "companyName": "Apify",
    "emails": ["hello@apify.com"],
    "phones": [],
    "socials": {
        "linkedin": "https://www.linkedin.com/company/apifytech",
        "twitter": "https://twitter.com/apify",
        "github": "https://github.com/apify"
    },
    "addresses": [],
    "contactPageUrls": ["https://apify.com/contact"],
    "pagesScraped": 3,
    "scrapedAt": "2026-07-13T12:00:00.000Z"
}
```

#### Key-value store exports

| Key            | Content type       | Description                     |
| -------------- | ------------------ | ------------------------------- |
| `CONTACTS.csv` | `text/csv`         | Flat CSV summary of all domains |
| `CONTACTS.md`  | `text/markdown`    | Human-readable Markdown report  |
| `OUTPUT`       | `application/json` | Run summary stats               |

See also: [`examples/output.json`](examples/output.json)

### How it works

1. **Start URLs** — Each unique domain is queued once (first URL wins as the primary).
2. **Homepage scrape** — Cheerio parses the page for emails, phones, socials, addresses, and company name.
3. **Contact link discovery** — Same-domain links matching contact/about/team/support/locations patterns are enqueued (up to `maxPagesPerDomain`).
4. **Merge & dedupe** — Contacts from all pages are merged per domain.
5. **Export** — One dataset item per domain, plus `CONTACTS.csv` and `CONTACTS.md`.

### Pricing

**$0.003 per domain result** using Apify pay-per-event (`apify-default-dataset-item`). Charged once per domain written to the dataset.

### Run locally

```bash
npm install
npm run build
npm test
apify run -p -i examples/input.json
```

### Limitations

- **Static HTML only** — Uses Cheerio (no browser). Contacts injected purely via client-side JavaScript may be missed.
- **Obfuscated emails** — Cloud-encoded or image-only emails are not decoded.
- **Address detection** — Best with schema.org / microdata; free-form footer text is heuristic.
- **Phone false positives** — Aggressive phone regex can occasionally match non-phone number sequences; noise filters reduce this.
- **Same-domain only** — Contact links on other domains are not followed.
- **Rate limits** — Aggressive settings may trigger site WAF/bot protection; enable Apify Proxy for production.

### FAQ

**How many pages are crawled per site?**\
Up to `maxPagesPerDomain` (default 10): the start URL plus discovered contact/about links.

**Can I extract only emails?**\
Yes. Set `includePhones`, `includeSocials`, and `includeAddresses` to `false`.

**Does it work without a proxy?**\
Yes for small local tests. For bulk production runs, enable `proxyConfiguration.useApifyProxy`.

**Where is the CSV?**\
In the run’s default key-value store under key `CONTACTS.csv`.

**One result or many?**\
One dataset item **per unique domain**, regardless of how many pages were scraped on that domain.

### Changelog

#### 1.0.0

- Initial release
- Email, phone, social, address extraction with CheerioCrawler
- Contact/about link following and per-domain deduplication
- CSV and Markdown exports
- Input flags for selective extraction
- LEAD\_GENERATION + DEVELOPER\_TOOLS categories

### License

Apache-2.0

# Actor input Schema

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

Homepage or landing page URLs to extract contacts from. One result is produced per unique domain.

## `maxPagesPerDomain` (type: `integer`):

Maximum number of pages to crawl per domain (homepage + contact/about links).

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

Maximum number of pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

How many times to retry failed HTTP requests before giving up.

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

Approximate delay between requests used for rate limiting (converted to maxRequestsPerMinute).

## `followContactLinks` (type: `boolean`):

When enabled, discovers and crawls contact, about, team, support, and location pages linked from the homepage.

## `includeEmails` (type: `boolean`):

Extract email addresses from mailto links, page text, and structured data.

## `includePhones` (type: `boolean`):

Extract phone numbers from tel: links, schema.org, and text patterns.

## `includeSocials` (type: `boolean`):

Extract LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok, and GitHub profile URLs.

## `includeAddresses` (type: `boolean`):

Extract physical addresses from schema.org PostalAddress, microdata, and footer blocks when detectable.

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

Optional Apify Proxy settings for production runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.apify.com"
    },
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://stripe.com"
    }
  ],
  "maxPagesPerDomain": 10,
  "maxConcurrency": 5,
  "maxRequestRetries": 3,
  "requestDelayMs": 200,
  "followContactLinks": true,
  "includeEmails": true,
  "includePhones": true,
  "includeSocials": true,
  "includeAddresses": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

## `markdown` (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 = {
    "startUrls": [
        {
            "url": "https://www.apify.com"
        },
        {
            "url": "https://www.shopify.com"
        },
        {
            "url": "https://stripe.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mighty_monk/website-contact-extractor").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 = { "startUrls": [
        { "url": "https://www.apify.com" },
        { "url": "https://www.shopify.com" },
        { "url": "https://stripe.com" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mighty_monk/website-contact-extractor").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 '{
  "startUrls": [
    {
      "url": "https://www.apify.com"
    },
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://stripe.com"
    }
  ]
}' |
apify call mighty_monk/website-contact-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Contact Extractor",
        "description": "Extract contact information (emails, phone numbers, social profiles, addresses) from websites by crawling homepage, contact, about, and footer links. One structured result per domain with CSV and Markdown export.",
        "version": "1.0",
        "x-build-id": "fRsOtcPKxbDASz7rc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mighty_monk~website-contact-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mighty_monk-website-contact-extractor",
                "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/mighty_monk~website-contact-extractor/runs": {
            "post": {
                "operationId": "runs-sync-mighty_monk-website-contact-extractor",
                "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/mighty_monk~website-contact-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-mighty_monk-website-contact-extractor",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Website URLs",
                        "type": "array",
                        "description": "Homepage or landing page URLs to extract contacts from. One result is produced per unique domain.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max pages per domain",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl per domain (homepage + contact/about links).",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pages processed in parallel.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry failed HTTP requests before giving up.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Approximate delay between requests used for rate limiting (converted to maxRequestsPerMinute).",
                        "default": 200
                    },
                    "followContactLinks": {
                        "title": "Follow contact/about links",
                        "type": "boolean",
                        "description": "When enabled, discovers and crawls contact, about, team, support, and location pages linked from the homepage.",
                        "default": true
                    },
                    "includeEmails": {
                        "title": "Extract emails",
                        "type": "boolean",
                        "description": "Extract email addresses from mailto links, page text, and structured data.",
                        "default": true
                    },
                    "includePhones": {
                        "title": "Extract phones",
                        "type": "boolean",
                        "description": "Extract phone numbers from tel: links, schema.org, and text patterns.",
                        "default": true
                    },
                    "includeSocials": {
                        "title": "Extract social profiles",
                        "type": "boolean",
                        "description": "Extract LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok, and GitHub profile URLs.",
                        "default": true
                    },
                    "includeAddresses": {
                        "title": "Extract addresses",
                        "type": "boolean",
                        "description": "Extract physical addresses from schema.org PostalAddress, microdata, and footer blocks when detectable.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for production runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
