# Website Emails Scraper (`automation-lab/website-emails-scraper`) Actor

Extract emails, phone numbers, social profiles, and contact/about page URLs from public websites. Fast HTTP crawler for lead enrichment.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Website Emails Scraper

Extract emails, phone numbers, social profile links, and contact/about pages from public websites.

Use this actor when you have a list of company websites and need a clean contact dataset for lead generation, recruiting, data enrichment, prospect research, or outreach preparation.

---

### What does Website Emails Scraper do?

Website Emails Scraper crawls public website HTML and looks for contact details that companies publish on their pages.

It starts from each URL or domain you provide, fetches the homepage, follows likely contact/about/team/support links, and returns one structured row per website.

Typical extracted data includes:

- 📧 Email addresses
- ☎️ Phone numbers
- 🔗 Social profile links
- 📄 Contact/about/team page URLs
- 🌐 Crawled URLs
- 🧾 Page titles and evidence snippets
- ✅ Crawl status and errors

---

### Who is it for?

This scraper is built for teams that already have website lists and need contact enrichment.

#### Sales and revenue teams

- 🧑‍💼 Enrich target account lists with public emails before outbound campaigns.
- 🧪 Test new market segments by scanning small batches of company domains.
- 🧾 Add evidence snippets so reps can verify where each contact was found.

#### Lead-generation and data teams

- 🏢 Clean prospect datasets for clients that need website-published contacts.
- 📊 Add email, phone, social link, and contact-page columns to existing business records.
- 🔁 Schedule repeat enrichment runs for fresh domains from forms, directories, or CRMs.

#### Recruiting, sourcing, and operations teams

- 🧲 Find company contact points and team/about pages for sourcing research.
- 🛒 Collect supplier or manufacturer contacts from official websites.
- 🧰 Connect Apify outputs to no-code workflows in Google Sheets, Make, Zapier, or CRMs.

---

### Why use this actor?

Manual contact lookup is slow and inconsistent. Website Emails Scraper gives you a repeatable extraction workflow with predictable output fields.

You can run a small batch to qualify a few companies or a larger batch to enrich a complete prospect list.

The actor is HTTP-first, lightweight, and designed for public web pages. It does not require browser automation for typical sites, which keeps runs fast and cost-efficient.

---

### What websites can it scan?

The actor scans public websites supplied by you.

Good inputs:

- Company homepages
- Agency websites
- SaaS websites
- Local business websites
- Supplier/manufacturer websites
- Public organization sites

Avoid inputs that require login, CAPTCHA completion, paid subscriptions, or private access.

---

### What data can I extract from websites?

| Field | Description |
| --- | --- |
| `startUrl` | URL submitted by the user after normalization |
| `domain` | Hostname of the scanned website |
| `normalizedDomain` | Domain without leading `www.` |
| `emails` | Email addresses found in HTML or text |
| `phones` | Phone-like numbers found in visible text |
| `socialLinks` | LinkedIn, Facebook, Instagram, X/Twitter, YouTube, TikTok, Pinterest URLs |
| `contactPageUrls` | Crawled pages that look like contact/about/team pages |
| `crawledUrls` | Pages fetched during the run |
| `pageTitles` | HTML page titles found while crawling |
| `matchedSnippets` | Short text snippets around matched contacts |
| `pagesCrawled` | Count of pages successfully crawled |
| `maxDepthReached` | Deepest crawl depth reached |
| `status` | `succeeded`, `partial`, or `failed` |
| `errors` | HTTP or network errors captured per website |
| `crawledAt` | ISO timestamp of extraction |

---

### How much does it cost to scrape emails from websites?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-result charge for each website contact result produced.

The default prefill scans one website with a low page limit, so your first run is inexpensive.

For best cost control:

- Start with 1-5 websites
- Keep `maxPagesPerSite` at 5 for testing
- Increase depth only when you need more coverage
- Export results and inspect match quality before scaling

---

### How to scrape website emails

1. Open the actor on Apify.
2. Add one or more website URLs in **Start URLs or domains**.
3. Keep **Maximum pages per website** at 5 for your first run.
4. Use **Maximum crawl depth** 1 to follow contact/about links.
5. Start the run.
6. Download the dataset as CSV, JSON, Excel, or via API.

---

### Input settings

#### Start URLs or domains

Provide public website URLs. Bare domains are accepted; the actor normalizes them to HTTPS.

Examples:

- `https://www.apify.com`
- `example.com`
- `https://company.example/contact`

#### Maximum pages per website

Limits how many pages are fetched for each website. The actor prioritizes likely contact pages, so a small value is often enough.

#### Maximum crawl depth

- `0` scans only the starting page.
- `1` follows contact/about/team links found on the starting page.
- `2` or `3` can discover more pages on complex sites.

#### Stay on the same domain

Enabled by default. This prevents the crawler from wandering to unrelated websites while still extracting social URLs from page content.

#### Request timeout

Controls how long to wait for each page before skipping it.

---

### Output example

```json
{
  "startUrl": "https://www.apify.com/",
  "domain": "www.apify.com",
  "normalizedDomain": "apify.com",
  "pagesCrawled": 5,
  "emails": ["support@example.com"],
  "phones": [],
  "socialLinks": ["https://www.linkedin.com/company/apifytech"],
  "contactPageUrls": ["https://www.apify.com/contact"],
  "status": "succeeded"
}
````

***

### Tips for better results

- ✅ Use official company homepages instead of search-result URLs.
- ✅ Keep crawl depth low unless you need maximum recall.
- ✅ Scan contact/about/team pages directly when you already know them.
- ✅ Review `matchedSnippets` to validate where a contact was found.
- ✅ Treat phone matches as leads to verify, because phone formats vary by country.

***

### Common use cases

#### Lead enrichment

Upload a list of domains from your CRM and enrich them with website-published email addresses.

#### Prospect research

Find general contact channels for companies in a niche before building an outreach campaign.

#### Supplier contact collection

Collect supplier emails and phone numbers from manufacturer or distributor websites.

#### Recruiting research

Find team/contact pages and social profiles for companies you want to approach.

#### Dataset cleanup

Validate which websites in an existing list expose contact details publicly.

***

### Integrations

You can connect the dataset to many workflows:

- Apify Dataset export to CSV or Excel
- Google Sheets via Apify integrations
- Make or Zapier automation
- CRM imports for HubSpot, Pipedrive, or Salesforce
- Data warehouses using the Apify API
- Internal enrichment pipelines using scheduled runs

***

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/website-emails-scraper').call({
  startUrls: [{ url: 'https://www.apify.com' }],
  maxPagesPerSite: 5,
  maxDepth: 1
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/website-emails-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.apify.com'}],
    'maxPagesPerSite': 5,
    'maxDepth': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~website-emails-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.apify.com"}],"maxPagesPerSite":5,"maxDepth":1}'
```

***

### MCP integration

Use this actor through Apify MCP when working in Claude Code or Claude Desktop.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/website-emails-scraper
```

Claude Code setup:

```bash
claude mcp add apify-website-emails --transport http https://mcp.apify.com/?tools=automation-lab/website-emails-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Scan these 20 company websites and return emails and LinkedIn profiles."
- "Find contact pages for the domains in this list."
- "Enrich this supplier list with public website emails."

***

### Scheduling

You can schedule recurring scans for changing website lists.

Common patterns:

- Weekly enrichment of new CRM domains
- Monthly supplier contact refresh
- Daily processing of new leads from a dataset

***

### Data quality notes

The actor extracts contacts that are present in public HTML or visible text. Some websites protect emails behind forms, images, JavaScript widgets, or anti-spam obfuscation.

The actor normalizes common email obfuscations such as `name [at] example [dot] com`.

Always verify contacts before sending outreach.

***

### Limitations

- It does not solve CAPTCHAs.
- It does not log in.
- It does not submit contact forms.
- It does not guarantee every website publishes an email.
- It may capture false-positive phone numbers on pages with many numeric values.

***

### FAQ and troubleshooting

#### Why did a website return no emails?

The website may not publish email addresses in its HTML. Try scanning its contact page directly or increasing `maxPagesPerSite`.

#### Why is the status `partial`?

At least one page was crawled, but one or more pages returned an HTTP/network error. Check the `errors` field for details.

#### Why are there no phone numbers?

Many companies use forms or social links instead of public phone numbers. Phone extraction also filters short/date-like values to reduce noise.

#### Can this actor submit contact forms?

No. It extracts public details from website pages and does not submit forms, log in, or interact with private areas.

***

### Legality and ethical use

This actor extracts data from public websites. Use it responsibly, respect website terms, and comply with applicable privacy, anti-spam, and data protection laws.

Do not use scraped contact details for unlawful spam or harassment.

***

### Related scrapers

Explore other Automation Lab actors for lead generation and enrichment:

- https://apify.com/automation-lab/email-finder
- https://apify.com/automation-lab/email-enrichment
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/linkedin-company-scraper

***

### Changelog

#### 0.1

Initial release: HTTP website crawler with email, phone, social link, contact page, snippet, and crawl status extraction.

# Actor input Schema

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

Public website homepages or domains to scan. The actor follows contact/about/team-style links on the same domain.

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

How many pages to fetch per website. Keep this low for quick lead checks; raise it for larger sites.

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

0 scans only the start page; 1 follows contact/about/team links found there; higher values inspect contact hubs more deeply.

## `sameDomainOnly` (type: `boolean`):

When enabled, external links are not crawled. Social/profile URLs are still extracted from page content.

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

Maximum time to wait for each page before skipping it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.apify.com"
    }
  ],
  "maxPagesPerSite": 5,
  "maxDepth": 1,
  "sameDomainOnly": true,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

## `websiteContacts` (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"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/website-emails-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://www.apify.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/website-emails-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://www.apify.com"
    }
  ]
}' |
apify call automation-lab/website-emails-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Emails Scraper",
        "description": "Extract emails, phone numbers, social profiles, and contact/about page URLs from public websites. Fast HTTP crawler for lead enrichment.",
        "version": "0.1",
        "x-build-id": "brnEUaAXECfbzzBJc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~website-emails-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-website-emails-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/automation-lab~website-emails-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-website-emails-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/automation-lab~website-emails-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-website-emails-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs or domains",
                        "type": "array",
                        "description": "Public website homepages or domains to scan. The actor follows contact/about/team-style links on the same domain.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPagesPerSite": {
                        "title": "Maximum pages per website",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many pages to fetch per website. Keep this low for quick lead checks; raise it for larger sites.",
                        "default": 5
                    },
                    "maxDepth": {
                        "title": "Maximum crawl depth",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "0 scans only the start page; 1 follows contact/about/team links found there; higher values inspect contact hubs more deeply.",
                        "default": 1
                    },
                    "sameDomainOnly": {
                        "title": "Stay on the same domain",
                        "type": "boolean",
                        "description": "When enabled, external links are not crawled. Social/profile URLs are still extracted from page content.",
                        "default": true
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout in seconds",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum time to wait for each page before skipping it.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
