# Contact Details Scraper – Emails, Phones & Social Links (`khadinakbar/contact-details-scraper`) Actor

Extract emails, phones, WhatsApp & 14 social profiles from any website. Supports direct URLs and natural-language search queries.

- **URL**: https://apify.com/khadinakbar/contact-details-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 per domain scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🔍 Contact Details Scraper – Emails, Phones & Social Links

Extract verified emails, phone numbers, physical addresses, WhatsApp numbers, and 14 social media profiles from any website. The **only contact scraper on Apify that accepts both direct URLs and natural-language search queries** — go from "plumbers in Chicago" to a full contact list in one run, no prep work needed.

### What Does Contact Details Scraper Do?

Contact Details Scraper crawls websites and extracts all publicly available contact information into one clean, deduplicated record per domain. Feed it a list of URLs, or describe the businesses you want to reach and let the actor find them via DuckDuckGo automatically.

### Why Use Contact Details Scraper?

- **Zero URL prep needed** — just type your target niche and location (e.g. "HVAC companies in Dallas Texas") and get back a contact list
- **One clean record per domain** — no duplicate rows per page, no noise, one consolidated output per website
- **Cloudflare-protected emails decoded** — automatically decodes `data-cfemail` attributes that hide emails from basic scrapers
- **14 social platforms in one shot** — LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok, GitHub, Pinterest, Telegram, Discord, Reddit, Medium, Threads, Snapchat

### What Data Can Contact Details Scraper Extract?

| Field | Description | Example |
|-------|-------------|---------|
| `domain` | Root domain of the website | `acme.com` |
| `company_name` | Business name from meta/OG/copyright/JSON-LD | `Acme Corp` |
| `emails` | All email addresses, deduplicated and junk-filtered | `["hello@acme.com", "sales@acme.com"]` |
| `phones` | Phone numbers from tel: links and body text | `["+1-312-555-0100"]` |
| `whatsapp` | WhatsApp contact numbers from wa.me links | `["+13125550199"]` |
| `social_links` | Object with 14 social platform URLs | `{"linkedin": "...", "instagram": "..."}` |
| `addresses` | Physical addresses from JSON-LD and text patterns | `["123 Main St, Chicago, IL 60601"]` |
| `pages_scraped` | How many pages were crawled for this domain | `7` |
| `source_url` | The original start URL | `https://acme.com` |
| `scraped_at` | ISO 8601 timestamp | `2026-04-13T10:30:00Z` |

### How to Use Contact Details Scraper

#### Option A — Direct URLs

Paste a list of website URLs you want to extract contacts from:

```json
{
    "startUrls": [
        { "url": "https://company-a.com" },
        { "url": "https://company-b.com" }
    ],
    "maxPagesPerDomain": 10,
    "maxResults": 50
}
````

#### Option B — Search Queries (Most Powerful)

Describe the businesses you want to find. The actor searches DuckDuckGo, finds the top websites, and extracts contacts automatically:

```json
{
    "searchQueries": [
        "dentists in Miami Florida",
        "web design agencies New York"
    ],
    "maxPagesPerDomain": 8,
    "maxResults": 30
}
```

#### Option C — Both Together

Combine URLs and search queries in the same run:

```json
{
    "startUrls": [
        { "url": "https://specific-company.com" }
    ],
    "searchQueries": ["roofing contractors Austin Texas"],
    "maxPagesPerDomain": 10,
    "maxResults": 25
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | Array | `[]` | Direct website URLs to extract contacts from |
| `searchQueries` | Array | `[]` | Natural-language search queries (e.g. "lawyers in Boston") |
| `maxPagesPerDomain` | Integer | `10` | Max pages to crawl per domain (contact/about pages crawled first) |
| `maxDepth` | Integer | `2` | How many links deep to follow from start URL |
| `maxResults` | Integer | `20` | Max number of domains to save to the dataset |
| `proxyConfig` | Object | Apify Proxy | Proxy configuration (datacenter recommended) |

### Output Example

```json
{
    "domain": "acme.com",
    "company_name": "Acme Corp",
    "emails": ["hello@acme.com", "sales@acme.com", "john@acme.com"],
    "phones": ["+1-312-555-0100", "(312) 555-0101"],
    "whatsapp": ["+13125550199"],
    "social_links": {
        "linkedin": "https://www.linkedin.com/company/acme-corp",
        "twitter": "https://twitter.com/acmecorp",
        "facebook": "https://www.facebook.com/acmecorp",
        "instagram": "https://www.instagram.com/acmecorp",
        "youtube": "https://www.youtube.com/channel/UC123",
        "github": "https://github.com/acme-corp"
    },
    "addresses": ["123 Main Street, Chicago, IL 60601"],
    "pages_scraped": 7,
    "source_url": "https://acme.com",
    "scraped_at": "2026-04-13T10:30:00.000Z"
}
```

### Pricing

This actor uses **pay-per-event pricing** at **$0.003 per domain result** — the most competitive per-domain price on Apify.

| Domains | Cost |
|---------|------|
| 10 domains | ~$0.03 |
| 100 domains | ~$0.30 |
| 500 domains | ~$1.50 |
| 1,000 domains | ~$3.00 |

Pricing is predictable: you pay per domain saved to your dataset, not per page crawled. The actor also charges the standard Apify `apify-actor-start` event on each run.

### Running via API

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('USERNAME/contact-details-scraper').call({
    searchQueries: ['dentists in Miami Florida'],
    maxPagesPerDomain: 8,
    maxResults: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items); // Array of contact records
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("USERNAME/contact-details-scraper").call(run_input={
    "searchQueries": ["dentists in Miami Florida"],
    "maxPagesPerDomain": 8,
    "maxResults": 25,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### How It Works

1. **Input processing** — For search queries, the actor fetches DuckDuckGo HTML results and extracts the top website URLs. For direct URLs, they are queued immediately.
2. **Priority crawling** — Contact, About, Team, and Impressum pages are crawled first (highest priority score) since they contain the most contact info.
3. **Multi-source extraction** — Each page is mined via: `mailto:` links (most reliable), `tel:` links, JSON-LD structured data (`@type: Organization`), WhatsApp links (`wa.me`), Cloudflare email decode (`data-cfemail`), and regex-based text extraction for emails and phones.
4. **Domain-level merging** — All findings from all pages of a domain are merged and deduplicated into one clean record.
5. **Social link detection** — 14 platform patterns are matched against the full HTML of each page.
6. **Save & charge** — The consolidated record is pushed to the dataset and the `domain-result` event is charged.

### Common Use Cases

- **B2B lead generation** — Build prospect lists of companies in your target niche and location
- **Sales outreach** — Get direct emails and LinkedIn profiles before your first touch
- **CRM enrichment** — Append missing contact data to existing account records
- **Agency prospecting** — Find SMBs in specific industries or cities for agency services
- **Market research** — Gather contact data across industries or regions
- **Competitor monitoring** — Discover which social platforms competitors actively use

### FAQ

**What if a website blocks scraping?**
The actor uses Apify's datacenter proxy pool by default, which rotates IPs. Enable "Residential Proxy" in the proxy config for heavily protected sites.

**Do search queries find email addresses directly?**
No — the actor searches for websites matching your query, then crawls those websites to extract contact info. It doesn't search email databases.

**How many pages per domain should I use?**
5–8 pages covers most small business websites. Use 10–15 for larger sites with many subpages. The actor always crawls contact/about/team pages first.

**Some emails look generic — can I filter them?**
The actor already filters obvious junk patterns (noreply@, mailer-daemon@, example.com, etc.). For further filtering, export to CSV and filter by email prefix patterns.

**Does it work on JavaScript-heavy sites?**
The actor uses a fast HTTP crawler. Most contact pages are server-rendered. If a site requires JavaScript to render contact info, those specific emails may not be found.

### Legal Disclaimer

This actor is designed for extracting publicly available contact information from websites. Users are solely responsible for ensuring their use complies with applicable laws, website terms of service, GDPR, CCPA, and other data protection regulations. Do not use this tool to collect personal data without a lawful basis. Apify is not responsible for any misuse of extracted data.

***

*Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools using Apify's platform.*

# Actor input Schema

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

Use this field when the user provides specific website URLs or domain URLs to extract contacts from. Each URL is crawled independently and returns one consolidated contact record per domain. Do NOT use this when the user describes a business type or industry — use searchQueries for that.

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

Use this field when the user provides a business type, niche, or location query instead of specific URLs. Examples: 'dentists in Miami Florida', 'web design agencies London', 'plumbers Chicago'. The actor searches DuckDuckGo and extracts contacts from the top results. Do NOT use this when the user provides direct URLs — use startUrls for that.

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

Maximum number of pages to crawl per domain. Higher values find more contacts but cost more. Contact/About/Team pages are crawled first. Recommended: 5–15.

## `maxDepth` (type: `integer`):

How many links deep to follow from the start URL. Depth 1 = only the homepage + directly linked pages. Depth 2 = one more level. Increase for large sites.

## `maxResults` (type: `integer`):

Maximum number of domains to extract contacts from and save to the dataset. Each domain = one output record. When using searchQueries, this caps how many websites from search results are processed.

## `proxyConfig` (type: `object`):

Proxy settings. Datacenter proxy is recommended for most websites. Use residential proxy only for sites that actively block scrapers.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "searchQueries": [],
  "maxPagesPerDomain": 10,
  "maxDepth": 2,
  "maxResults": 20,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset of contact records — one per domain — with emails, phones, social links, and addresses.

# 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://apify.com"
        }
    ],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/contact-details-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 = {
    "startUrls": [{ "url": "https://apify.com" }],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/contact-details-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 '{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "searchQueries": []
}' |
apify call khadinakbar/contact-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Contact Details Scraper – Emails, Phones & Social Links",
        "description": "Extract emails, phones, WhatsApp & 14 social profiles from any website. Supports direct URLs and natural-language search queries.",
        "version": "1.0",
        "x-build-id": "QwocQmsbBAqhfvWUl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~contact-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-contact-details-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/khadinakbar~contact-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-contact-details-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/khadinakbar~contact-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-contact-details-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific website URLs or domain URLs to extract contacts from. Each URL is crawled independently and returns one consolidated contact record per domain. Do NOT use this when the user describes a business type or industry — use searchQueries for that.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Use this field when the user provides a business type, niche, or location query instead of specific URLs. Examples: 'dentists in Miami Florida', 'web design agencies London', 'plumbers Chicago'. The actor searches DuckDuckGo and extracts contacts from the top results. Do NOT use this when the user provides direct URLs — use startUrls for that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max Pages per Domain",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl per domain. Higher values find more contacts but cost more. Contact/About/Team pages are crawled first. Recommended: 5–15.",
                        "default": 10
                    },
                    "maxDepth": {
                        "title": "Max Link Depth",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many links deep to follow from the start URL. Depth 1 = only the homepage + directly linked pages. Depth 2 = one more level. Increase for large sites.",
                        "default": 2
                    },
                    "maxResults": {
                        "title": "Max Domains (Results)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of domains to extract contacts from and save to the dataset. Each domain = one output record. When using searchQueries, this caps how many websites from search results are processed.",
                        "default": 20
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxy is recommended for most websites. Use residential proxy only for sites that actively block scrapers.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```