# Wordpress Email Scraper Fast (`solid-scraper/wordpress-email-scraper-fast`) Actor

📧 WordPress Email Scraper Fast extracts emails from websites quickly and accurately for lead generation. Perfect for marketers, agencies & sales teams—save time, boost outreach, and find targeted contacts with ease. 🚀

- **URL**: https://apify.com/solid-scraper/wordpress-email-scraper-fast.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Wordpress Email Scraper - Fast, Advanced and Cheapest 📬

**Wordpress Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Wordpress-based public web content using the keywords and email-domain filters you specify. It’s built to help you quickly build lead lists and find the right contact emails—whether you’re a marketer, researcher, or data analyst—so you can move faster without manual searching.

---

### Why choose Wordpress Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
|---|---|
| ✅ **Keyword and domain targeting** | Helps you focus on the contacts you want by using your selected keywords and custom email domains like `@gmail.com` |
| ✅ **Fast email scraper behavior with limits** | Lets you control cost and runtime by stopping once your `maxEmails` target is reached |
| ✅ **Built-in resilience** | Includes retry and fallback logic so scraping can keep working even when some pages fail |
| ✅ **Structured, ready-to-use output** | Pushes consistent lead records (keyword, title, description, url, email) into the dataset for easy export |
| ✅ **Incremental saving during the run** | Writes results as they’re found, so you don’t lose data if the run stops early |
| ✅ **Automation-friendly workflow** | Designed to run repeatedly for ongoing **wordpress bulk email finder** and **wordpress lead generation email scraper** use cases |

---

### Key features

- 🔎 **Targeted Wordpress email extraction**: Uses your provided keywords and custom email domains to find relevant email addresses
- 🧠 **Smart filtering via email domains**: Narrows results using the domains you include (for example `@gmail.com`, `@yahoo.com`)
- 🛡️ **Reliability-focused scraping**: Built to handle failures with retries and fallbacks during page fetching
- 💾 **Real-time dataset pushes**: Each discovered lead is pushed immediately to the dataset as structured data
- ⏱️ **Run control with `maxEmails`**: Stops when the requested number of unique emails is reached to help manage scraping time and cost
- ♻️ **Progress resume support**: Maintains progress so you can continue later without starting from zero
- 📊 **Clean output fields for analysis**: Records include `keyword`, `title`, `description`, `url`, and `email`—ready for CRM import or spreadsheet work

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords or queries to search for (the actor will extract emails based on these keywords). |
| `location` | ❌ | Optional location filter as a plain text string. Leave empty if you don’t need location narrowing. |
| `customDomains` | ❌ | List of custom email domains (for example `@gmail.com`, `@yahoo.com`). These guide which email addresses are extracted. |
| `maxEmails` | ❌ | Maximum number of emails to collect. The scraper stops once this limit is reached. Higher limits can take longer and don’t guarantee reaching the exact number. Minimum is 1, maximum is 10000. |

> Note: If you run on a free Apify plan, the actor enforces a result limit of **100 emails maximum**.

***

### Output

The actor saves each lead record in JSON format into the **“Wordpress Emails Dataset”** dataset.

```json
{
  "network": "Wordpress.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | Source network label for each lead record. (Set to `Wordpress.com`.) |
| `keyword` | string | The keyword that produced this lead. |
| `title` | string | The title text from the discovered result item (or `No title` if missing). |
| `description` | string | Extracted text content (or `No data` if missing). |
| `url` | string | The discovered URL associated with the lead (or `No URL` if missing). |
| `email` | string | The extracted email address. |

Dataset export: You can download the dataset from the Apify Console in standard formats (for example JSON/CSV) for analysis and outreach workflows.

***

### How to use Wordpress Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**\
   Search for **Wordpress Email Scraper - Fast, Advanced and Cheapest** in the Actors directory.

3. **Configure Input**\
   In the **INPUT** panel, set:
   `keywords` (required), plus optionally `location`, `customDomains`, and `maxEmails`.

4. **Choose your scale**\
   If you’re doing **wordpress bulk email finder** or **email list building wordpress scraper** workflows, increase `maxEmails` (keeping in mind runtime can grow). On free plan runs, the actor caps results at 100 emails.

5. **Run the actor**\
   Click **Run** to start the extraction.

6. **Monitor progress in logs**\
   Watch the live logs for found emails and progress updates. The actor also maintains a resume state, so interrupted runs can be continued.

7. **Open the dataset output**\
   After completion, go to the **OUTPUT** tab and open **“Scraped Leads”** inside **Wordpress Emails Dataset**.

8. **Export your leads**\
   Export the dataset (JSON/CSV) and load it into your CRM, spreadsheet, or analysis pipeline.

No coding required—get results in minutes with this **wordpress email scraper**.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for “fast email scraper wordpress” workflows**: Built for quick lead list creation using keyword + domain targeting for **wordpress contact email extraction**
- 🔄 **Resilient page fetching**: Includes retries and fallbacks to keep data collection moving when some pages don’t respond well
- 🧩 **Progress-aware resume**: Uses saved progress to continue from where it left off, which is great for long-running **wordpress bulk email finder** batches
- 📌 **Data completeness for outreach**: Each record includes the lead `email` alongside `keyword`, `title`, `description`, and `url` for context
- 🗂️ **Structured dataset output**: The actor pushes standardized records for easy export and automation (a strong fit for **wordpress lead generation email scraper** pipelines)

***

### Best use cases

- 📈 **Lead generation for WordPress businesses**: Build outreach lists by extracting relevant contact emails for decision-makers (e.g., founders and managers)
- 🧪 **Market research and competitor intel**: Compare email availability across niches by varying `keywords` and email domains in your **best wordpress email extractor** workflow
- 🛒 **WooCommerce outreach targeting**: Use focused keyword sets to support **woocommerce email scraper** lead discovery
- ✉️ **Cold email list building**: Create a reusable **email scraping tool for wordpress** dataset for campaigns and A/B testing
- 🔎 **Research on contact formats**: Identify which email domains appear most often for a given keyword theme (useful for data analysts)
- 🧱 **CRM enrichment automation**: Feed the scraped dataset into your pipeline to enrich contacts while maintaining context fields like `url` and `description`
- 🧰 **Low-cost batch sourcing**: Use `maxEmails` to control run time and cost for **cheap email scraper wordpress** projects

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array (required)
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of domains (optional)
  - ✅ `maxEmails` as an integer between 1 and 10000 (optional)

- **Proxy Support**
  - ✅ Built-in proxy support for more reliable scraping

- **Retry Mechanism**
  - ✅ Includes retry and fallback behavior for resilience when some pages fail

- **Dataset Structure**
  - ✅ Dataset title: **Wordpress Emails Dataset**
  - ✅ Dataset view: **Scraped Leads**
  - ✅ Output fields: `network`, `keyword`, `title`, `description`, `url`, `email`

- **Rate Limits & Performance**
  - ✅ Performance depends on page availability and your `maxEmails` target
  - ✅ The actor stops once `maxEmails` is reached (when provided)

- **Limitations**
  - ❌ Results may be limited if there are fewer matching public pages or fewer emails for your specified domains/keywords
  - ❌ The actor does not guarantee reaching `maxEmails`; it stops based on what it finds during the run

***

### FAQ

#### How many emails can I scrape with Wordpress Email Scraper - Fast, Advanced and Cheapest?

If you provide `maxEmails`, the actor stops once that limit is reached. On free Apify plan runs, the actor enforces a maximum of **100 emails**.

#### What input do I need to start?

You must provide `keywords`. Optionally, you can add `location`, choose `customDomains` (such as `@gmail.com`), and set `maxEmails` to control how many unique emails you want to collect.

#### What email types does it extract?

It extracts email addresses that match the email domains you include in `customDomains`. That domain filter is how you control which email addresses are considered relevant.

#### Where do the results go?

The actor pushes each lead record into the dataset **Wordpress Emails Dataset**, under the **Scraped Leads** view. Each dataset item includes `keyword`, `title`, `description`, `url`, and `email`.

#### Can I resume a run if it stops?

Yes. The actor maintains progress and can resume using saved state so you don’t have to start from scratch.

#### Do I need to write any code to use this actor?

No. You can run it from Apify Console by filling in the input fields.

#### Is this tool legal to use for lead generation?

✅ The actor only works with **publicly accessible sources**. However, legal compliance (including GDPR/CCPA considerations, spam regulations, and platform terms) is your responsibility.

#### How can I request data removal?

For data removal requests, contact <dataforleads@gmail.com>.

***

### Support & feature requests

Have questions or want to improve Wordpress Email Scraper - Fast, Advanced and Cheapest for your **wordpress email scraper** workflow? Tell us what you need.

💡 **Feature Requests**: Examples include adding more output context fields, improving dataset formatting, or expanding export options.\
📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape future improvements to this advanced and budget-friendly **wordpress email extractor**.

***

### Wordpress Email Scraper - Fast, Advanced and Cheapest

*Get the most comprehensive, SEO-optimized Wordpress Email Scraper - Fast, Advanced and Cheapest workflow for faster lead discovery.*

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/wordpress-email-scraper-fast").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/wordpress-email-scraper-fast").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call solid-scraper/wordpress-email-scraper-fast --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wordpress Email Scraper Fast",
        "description": "📧 WordPress Email Scraper Fast extracts emails from websites quickly and accurately for lead generation. Perfect for marketers, agencies & sales teams—save time, boost outreach, and find targeted contacts with ease. 🚀",
        "version": "1.0",
        "x-build-id": "KeC59c6JSXqwqWMKC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~wordpress-email-scraper-fast/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-wordpress-email-scraper-fast",
                "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/solid-scraper~wordpress-email-scraper-fast/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-wordpress-email-scraper-fast",
                "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/solid-scraper~wordpress-email-scraper-fast/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-wordpress-email-scraper-fast",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
