# Company Contact Scraper (`dxbear/company-contact-scraper`) Actor

🚀 Scrape leads, prospect emails & uncover employee profiles from any company domain — names, positions, LinkedIn URLs, and public contact info delivered in seconds.

- **URL**: https://apify.com/dxbear/company-contact-scraper.md
- **Developed by:** [Dxbear](https://apify.com/dxbear) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 employee / prospect founds

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

### 🔎 Overview

**Company Contact Scraper** Just enter a domain, and you can instantly uncover a wealth of information about any company, such as:

- 🏢 Company information — name, industry, size, location, LinkedIn page and more
- 👤 Employee profiles: names, job titles, and LinkedIn URLs
- 📧 Personal work emails: with confidence scores
- 📬 Company emails: publicly found addresses at that domain
- 📣 Generic inboxes: like `sales@`, `info@`, `support@`


![company contact scraper features](https://raw.githubusercontent.com/dx-bear/apify-actors-imgs/refs/heads/main/Gemini_Generated_Image_6w9wzf6w9wzf6w9w.png)

### 🚀 Quick Start

1. Click **Try for free**
2. Create a free Apify account (if you don't have one)
3. Go to the **Input** tab

4. Enter your list of domains, one per line — for example:
apify.com , spyfu.com , mangools.com
5. In the input section, choose what data you want to retrieve
6. Click **Run**
In a few seconds you'll get a rich contact profile for each company — employees, emails, and company info, all in one place.


### ⚙️ Input

| Field | Type | Description |
|-------|------|-------------|
| `domains` | array | List of company domains to look up |
| `getCompanyInfo` | boolean | Get company name, industry, size, location, and LinkedIn |
| `getEmployees` | boolean | Get employee names, job titles, and LinkedIn URLs |
| `getCompanyPublicEmails` | boolean | Get publicly found personal emails at the domain |
| `getCompanyGenericEmails` | boolean | Get generic inboxes like `sales@`, `info@`, `support@` |

```json
{
  "domains": [
    "spyfu.com",
    "mangools.com",
    "apify.com",
    "lovable.dev"
  ],
  "getCompanyGenericEmails": true,
  "getCompanyInfo": true,
  "getCompanyPublicEmails": true,
  "getEmployees": true
}
````

***

### 📦 Output

Each domain returns a structured object with the data you selected:

```json
{
  "Domain": "spyfu.com",
  "CompanyInfo": {
    "name": "SpyFu",
    "industry": "Internet",
    "company_type": "Privately Held",
    "size": "11-50",
    "employees_num": 17,
    "founded": "2005",
    "locality": "Scottsdale, Arizona, United States",
    "url": "https://www.spyfu.com",
    "social": [{ "type": "linkedIn", "link": "https://www.linkedin.com/company/spyfu" }]
  },
  "CompanyEmployees": [
    {
      "name": "Mike Roberts",
      "position": "Founder and CEO",
      "sourcePage": "https://www.linkedin.com/in/mrspy",
      "emails": [
        { "email": "m****e@spyfu.com", "probability": 20 }
      ]
    }
  ],
  "CompanyEmails": [
    { "email": "mike@spyfu.com" },
    { "email": "jeff@spyfu.com" }
  ],
  "GenericEmails": [
    { "email": "sales@spyfu.com" },
    { "email": "support@spyfu.com" }
  ]
}
```

### 🎯 Who Is This For?

**Company Contact Scraper** designed specifically for sales teams, recruiters, and growth professionals who want to quickly transform company domains into valuable leads and gather prospect contact information.

#### 🧑‍💼 Sales & Business Development

Stop wasting time tracking down contacts! Paste in your list of target domains, and you'll receive decision-maker names, titles, LinkedIn profiles, and public emails, all ready to seamlessly integrate into your outreach sequence or CRM.

#### 📣 Marketers & Growth Teams

Enrich your target accounts with real contact data and reach the people who actually matter — CMOs, heads of growth, and demand gen leads.

#### 🏢 Recruiters

Map out the org structure of any company before you pick up the phone. Know who's in engineering, HR, or leadership. and find a way to reach them directly.

#### 🔍 Researchers & Analysts

Are you looking to create a dataset of companies within a specific niche? You can gather structured and consistent data from hundreds of domains all at once. think company size, industry, founding year, and key contacts, all neatly organized in one spot.

#### 🤝 Founders & Consultants

Doing customer discovery or partnership outreach? Skip the guesswork and go straight to the inbox of the right person at any company you want to connect with.

***

> ⚡ Whether you're prospecting, enriching, or researching — if you have a domain, this actor turns it into a full contact profile.

### 💰 Pricing

This actor uses **pay-per-result** pricing — you only pay for the data you actually get back.

| Data Type | Free | Starter | Scale | Business |
|-----------|------|---------|-------|----------|
| Employee / Prospect found | $3.00 / 1K | $2.50 / 1K | $1.50 / 1K | $1.00 / 1K |
| Public email found | $5.00 / 1K | $4.00 / 1K | $3.00 / 1K | $2.00 / 1K |
| Company information | $1.00 / 1K | $0.80 / 1K | $0.60 / 1K | $0.50 / 1K |
| Generic email list | $2.00 / 1K | $0.80 / 1K | $0.60 / 1K | $0.40 / 1K |

> 💡 Higher Apify plans unlock better rates. [See all Apify plans →](https://apify.com/pricing)

***

#### How billing works

- **Employees & prospects** — charged per profile returned across all domains
- **Public emails** — charged per email address found across all domains
- **Company information** — charged **once per domain**, regardless of how much data is returned
- **Generic email list** — charged **once per domain**, regardless of how many generic emails are found (e.g. `sales@`, `info@`, `support@`)
- **Platform usage** — Apify's standard compute costs apply on top, and are cheaper on higher plans

### 🔗 Integrations & Automation

Company Contact Scraper integrates seamlessly with your existing tools and workflows, making it easy to automate lead generation, company enrichment, and contact discovery at scale.

#### ⚡ Automation Platforms

Connect the actor to popular automation platforms:

- [n8n](https://n8n.io/)
- [Zapier](https://zapier.com/)
- [Make](https://www.make.com/)
- [Airtable](https://www.airtable.com/)
- Google Sheets
- CRM systems
- Custom applications

Use these integrations to automatically discover employee profiles, enrich company records, collect business emails, and sync data across your sales and marketing stack.

#### 🔌 API Access

Need full control? Run the actor programmatically using the Apify API.

With the API you can:

- Start actor runs
- Pass input dynamically
- Monitor run status
- Retrieve results in JSON format
- Integrate with your applications and backend services

API Documentation:

- https://docs.apify.com/api/v2

#### 🤖 MCP Server Support

This actor can also be accessed through Apify's MCP (Model Context Protocol) server, allowing AI assistants and MCP-compatible tools to discover company information, employee profiles, and business contact data directly.

MCP Documentation:

- https://docs.apify.com/platform/integrations/mcp

#### 📚 Documentation

For detailed setup instructions, API examples, integration guides, and advanced usage, please refer to the official Apify documentation:

- https://docs.apify.com/

### ❓ Frequently Asked Questions

#### Why do prospects not come with valid emails?

This actor is designed to discover **all available employees and prospects** associated with a company. Not every employee has a publicly available or verified email address.

In most cases, you don't need every employee. Instead, filter the prospects based on the roles, departments, or seniority levels you need, then use our B2B Email Finder actor to discover and verify contact information.

**B2B Email Finder:**

https://apify.com/dxbear/b2b-email-finder

***

#### Why does the actor store some data in the Key-Value Store?

The actor stores a small amount of data in Apify's Key-Value Store to save login sessions for certain services and accounts.

This allows the actor to quickly access resources without creating a new session every time it runs, resulting in faster execution, lower resource consumption, and improved reliability.

***

#### What are the minimum Apify requirements to run the actor?

The actor can run with as little as **1 GB RAM** for small tasks.

However, we recommend:

- **1 GB RAM** for testing and single-domain lookups
- **4 GB RAM** for medium and large workloads
- **8 GB+ RAM** for long-running or high-volume jobs

The actor uses a headless browser and processes multiple data sources, so larger workloads may require additional resources.

***

#### I entered a valid company domain, but no data was returned. Why?

While we have access to a large database containing millions of companies, we cannot guarantee that every company exists in our data sources.

Possible reasons include:

- The company is not present in our database
- The company has limited public information available
- The domain is very new
- The company has little or no online presence

Unfortunately, some domains may return limited or no results.

***

#### I only want employee/prospect data. Can I disable the other data?

Yes, absolutely.

You can disable company information, public emails, generic emails, and any other optional outputs.

Simply enable the data you need and disable the rest to reduce runtime and resource usage.

***

#### The actor failed to run. What should I do?

Occasionally, runs may fail because of temporary network issues, proxy availability, or third-party service interruptions.

Before reporting a problem:

1. Try running the actor again.
2. Verify that your input is valid.
3. Check that sufficient memory has been allocated.

If the issue persists, please open an issue on the actor page. The developer is very active and typically responds within minutes.

***

#### Can I contact you for support?

Yes, support is always welcome.

📧 <support@scravity.com>

📧 <ahmed@scravity.com>

We are happy to help with setup, troubleshooting, feature requests, and general questions.

***

#### I entered multiple domains, but only one was processed. Why?

Free Apify users can process **one domain per run**.

This limitation helps:

- Prevent abuse
- Reduce server load
- Ensure consistent service quality
- Keep the actor available for all users

You can still use all features of the actor, but free accounts are limited to a single domain per run.

### 🛠️ Support & Troubleshooting

If you encounter a problem, something is broken, or the actor is not working as expected, please consider the following steps before leaving a negative review:

#### 📬 How to Get Help

- 🐛 **Submit an Issue:** Open an issue. I am highly active, and you will receive a reply within minutes! ⏱️
- ✉️ **Contact via Email:** Prefer direct communication? Feel free to reach out to me directly via email.

#### ⭐ Why Good Reviews Matter

Positive reviews are the fuel that helps me continue maintaining, updating, and fixing this actor! 🚀 Your support keeps this actor alive.

> ⚠️ **VERY IMPORTANT NOTE:** Please reach out before leaving a bad review! Most issues are caused by minor configuration errors or temporary website changes, which can usually be fixed in just a few minutes.

If I fail to resolve your issue after we have tried, you are absolutely welcome to share your honest feedback. My goal is to ensure everything works perfectly for you! 🤝💯

# Actor input Schema

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

List of company domains to scrape. Enter plain domains only, e.g. example.com (no http:// or https://).

## `getCompanyInfo` (type: `boolean`):

If enabled, the Actor will extract general company information.

## `getEmployees` (type: `boolean`):

If enabled, the Actor will extract employee data, including names, job titles, and LinkedIn profiles when available.

## `getCompanyPublicEmails` (type: `boolean`):

If enabled, the Actor will extract publicly available company emails.

## `getCompanyGenericEmails` (type: `boolean`):

If enabled, the Actor will extract generic company emails (e.g. info@, contact@).

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "spyfu.com"
  ],
  "getCompanyInfo": true,
  "getEmployees": true,
  "getCompanyPublicEmails": false,
  "getCompanyGenericEmails": false
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("dxbear/company-contact-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "apify.com",
        "spyfu.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("dxbear/company-contact-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "spyfu.com"
  ]
}' |
apify call dxbear/company-contact-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Contact Scraper",
        "description": "🚀 Scrape leads, prospect emails & uncover employee profiles from any company domain — names, positions, LinkedIn URLs, and public contact info delivered in seconds.",
        "version": "1.0",
        "x-build-id": "NuQZwdIKf6apK97Yw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dxbear~company-contact-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dxbear-company-contact-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dxbear~company-contact-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dxbear-company-contact-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dxbear~company-contact-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dxbear-company-contact-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains",
                    "getCompanyInfo"
                ],
                "properties": {
                    "domains": {
                        "title": "Company Domains",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of company domains to scrape. Enter plain domains only, e.g. example.com (no http:// or https://).",
                        "items": {
                            "type": "string",
                            "pattern": "^(?!https?:\\/\\/)([a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,}$"
                        },
                        "default": [
                            "apify.com"
                        ]
                    },
                    "getCompanyInfo": {
                        "title": "Get company info",
                        "type": "boolean",
                        "description": "If enabled, the Actor will extract general company information.",
                        "default": true
                    },
                    "getEmployees": {
                        "title": "Get Employee Data",
                        "type": "boolean",
                        "description": "If enabled, the Actor will extract employee data, including names, job titles, and LinkedIn profiles when available.",
                        "default": true
                    },
                    "getCompanyPublicEmails": {
                        "title": "Get company public emails",
                        "type": "boolean",
                        "description": "If enabled, the Actor will extract publicly available company emails.",
                        "default": false
                    },
                    "getCompanyGenericEmails": {
                        "title": "Get company generic emails",
                        "type": "boolean",
                        "description": "If enabled, the Actor will extract generic company emails (e.g. info@, contact@).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
