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

🚀 Speed up prospecting with Email Scraper Fast! Scrape email addresses from websites effortlessly, with reliable performance. ✅ Perfect for B2B lead gen, sales, and outreach—find leads faster, grow faster.

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

## Pricing

from $0.01 / 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.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

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

Manually browsing Wordpress sites to collect emails wastes hours you don’t have. **Wordpress Email Scraper - Fast, Advanced and Cheapest** extracts emails from Wordpress based on the keywords and filters you choose. It’s a fast Wordpress email harvesting tool for marketers, recruiters, and growth teams who need thousands of records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Wordpress.com",
  "keyword": "manager",
  "title": "Example Site Role Page",
  "description": "Contact us at hello@example.com for collaborations.",
  "url": "https://example.wordpress.com/contact/",
  "email": "hello@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network label included with each lead record (returned as `Wordpress.com`). |
| `keyword` | string | The keyword that drove the match, so you can trace lead intent back to your query. |
| `title` | string | The page title captured alongside the email so your team can judge context quickly. |
| `description` | string | The extracted surrounding text where the email was found, useful for validation and notes. |
| `url` | string | The page URL where the email appeared, so you can click back to verify. |
| `email` | string | The extracted email address that you can use for outreach or list building. |
| `error_message` | string | Error details when something goes wrong while pushing data (if present in your run outputs/logs). |
| `status` | string | A status indicator in case your environment returns one (depends on run behavior). |
| `success` | boolean | Indicates whether the record was processed successfully (depends on run behavior). |
| `timestamp` | string | Time captured for the record if your run environment includes it. |
| `id` | string | Record identifier if your integration adds it. |
| `raw` | object | Raw object content if your dataset transformation includes it. |
| `email_source` | string | Email provenance label if your pipeline adds it. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

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

There are a lot of ways to pull email leads from the web — here’s what sets **Wordpress Email Scraper - Fast, Advanced and Cheapest** apart.

#### Targeted keyword-led lead building

You provide `keywords` and optionally `location` plus a list of `customDomains`. The actor uses your filters to focus on more relevant email harvesting results instead of collecting generic noise, making it a strong fit for a Wordpress email list builder plugin workflow.

#### Built for fast, bulk extraction

The actor iterates through your keyword and domain combinations and pushes results incrementally to your dataset. That means you can build a Wordpress bulk email finder pipeline without waiting for a full run to finish.

#### Deduplicated emails across the run

Emails are tracked during the run (`seen_emails`), so duplicates are skipped. This helps you keep cleaner leads for outbound workflows and reduces wasted CRM cleanup time.

#### Resilient runs with progress saving

The actor maintains progress state and saves it while data is being collected. If a run stops early, it can resume from the saved cursor state to continue where it left off.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords or queries to search for when extracting emails from Wordpress. |
| `location` | ⬜ | A location string to filter results; leave it empty for broader coverage. |
| `customDomains` | ⬜ | A list of email domains (like `@gmail.com`, `@yahoo.com`) used to narrow which emails get collected. |
| `maxEmails` | ⬜ | Caps how many unique emails to collect before the scraper stops (helps control scraping time and cost). |

***

### Core Capabilities

#### Keyword and domain targeting

You control what the scraper looks for by combining `keywords` with `customDomains`. This makes it easy to build an email scraping tool for lead generation that targets specific inbox providers (or business domains) instead of capturing everything.

#### Extracts emails found in Wordpress content

The actor extracts email addresses from Wordpress using the provided filters. It pushes structured records to the Apify dataset so you can immediately use the results for outreach or analysis.

#### Real-time dataset writing

Each time an email is found, the actor pushes a row into the dataset. This means you get usable data quickly and can monitor progress as the run continues.

#### Deduplication for cleaner lead lists

The actor keeps track of already-seen emails during the run. That helps you produce a more reliable Wordpress email address extractor output suitable for marketing lists and research.

#### Progress persistence for longer runs

The actor saves cursor and seen-email state while scraping. This helps with resilience for bigger searches or higher limits where runs may take longer.

***

### Who Gets the Most Out of This

Here's how different teams put Wordpress Email Scraper - Fast, Advanced and Cheapest to work:

**Marketing teams & outbound managers** — Use targeted `keywords` and `customDomains` to build a Wordpress email list builder plugin pipeline. The result is a ready-to-import email dataset that supports outreach campaigns and segmentation.

**Recruiters & talent sourcers** — Extract emails connected to roles and titles by focusing on leadership or job-title keywords. You can quickly assemble a Wordpress bulk email finder list to contact relevant decision-makers.

**Data analysts & researchers** — Turn public web data into structured datasets for analysis. The dataset fields (`keyword`, `title`, `url`, `email`, plus surrounding `description`) make it easier to measure which search criteria produce better lead quality.

**Automation specialists & developers** — Integrate the actor into data workflows where you trigger runs and ingest dataset outputs. You can connect it to downstream systems using the Apify API and exports to keep lead generation automation running end-to-end.

**E-commerce & community managers** — Use role-based keywords to find emails associated with Wordpress communities and site owners. It’s a practical fit when you’re looking for communication contacts related to brands, creators, or site operators.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Wordpress Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find “Wordpress Email Scraper - Fast, Advanced and Cheapest”.
2. **Enter your inputs** — fill in `keywords` (required), and optionally set `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use Apify’s proxy options for more reliable scraping runs.
4. **Hit Run and watch the live log** — monitor progress as emails are discovered and pushed to the dataset.
5. **View results in the dataset tab** — see each record as it’s captured (including `url` and `email`).
6. **Export as JSON, CSV, or Excel** — download the dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Wordpress Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export your Apify dataset as **JSON, CSV, or Excel** from the dataset tab. From there, teams typically import into CRMs, marketing tools, or research notebooks for filtering and enrichment.

You can also automate downstream steps using **Zapier / Make**, and if you need programmatic access, pull results via the **Apify API** (see: https://apify.com/docs/api). For event-driven pipelines, you can trigger actions with **webhooks** when a run completes.

***

### Pricing & Free Trial

Wordpress Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Apify pricing is based on platform usage (compute units). For exact costs and plan details, check the Apify pricing page and select the option that matches your batch size and frequency. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Request throttling and blocks | Uses built-in resilience so runs can continue instead of failing instantly. |
| Longer searches | Saves progress so you can resume when runs take more time. |
| Result limits | Enforces `maxEmails` to stop once the target is reached. |
| Incremental data delivery | Pushes data to your dataset as results are found. |
| Duplicate emails | Skips emails already seen earlier in the same run. |

Limitations: the actor works with **publicly available data** and only extracts emails that appear in accessible Wordpress content. If emails aren’t present or are outside your `customDomains` filter, you may collect fewer results than expected. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. The actor runs on the Apify platform, which includes a free tier so you can test before scaling up. Availability and credit amounts depend on your Apify account.

#### Do I need to log in to Wordpress to use this?

No. This actor is designed to work with publicly available data and does not require Wordpress account login from you.

#### How accurate is the data?

Accuracy depends on what the email addresses actually appear as in the publicly available Wordpress content. The actor extracts email addresses and includes the surrounding `description` and the `url` so you can review context.

#### How many results can I get per run?

You can control the number of collected emails using `maxEmails` (default is 20, with a maximum of 10000). The scraper stops once it reaches your requested cap.

#### How often is the data updated / how fresh is it?

The data is collected at run time. If you need fresher results, run the actor again with the same inputs when you’re ready to refresh your Wordpress email list builder workflow.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor uses **publicly available data** and you’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when you store and use email leads.

#### Can I export results to Google Sheets or Excel?

Yes. You can download your Apify dataset as JSON, CSV, or Excel directly from the Apify dashboard, and then move it into tools like spreadsheets and CRMs.

#### Can I run this on a schedule automatically?

Yes. Since this is an Apify actor, you can schedule runs using Apify’s scheduling features. This helps keep your email scraping tool for lead generation updated over time.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically through the Apify API. This is useful for building automation around your Wordpress email address extractor pipeline.

#### What happens if the actor hits an error?

Errors while pushing data are logged, and the actor uses progress saving to reduce the need to restart from scratch. If results are limited, widening `keywords` or adjusting `customDomains` can improve coverage.

***

### Need Help or Have a Request?

Got a question about Wordpress Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup guidance and welcome requests like batch CSV upload and webhook notifications on run completion.

***

### Disclaimer & Responsible Use

*Wordpress Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build targeted Wordpress email leads — start your free run today.*

The actor works with **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for compliance with GDPR, CCPA, and applicable platform Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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 scraperoka/wordpress-email-scraper-fast --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wordpress Email Scraper Fast",
        "description": "🚀 Speed up prospecting with Email Scraper Fast! Scrape email addresses from websites effortlessly, with reliable performance. ✅ Perfect for B2B lead gen, sales, and outreach—find leads faster, grow faster.",
        "version": "1.0",
        "x-build-id": "TvUkwVeV955uQn4Gg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~wordpress-email-scraper-fast/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~wordpress-email-scraper-fast/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~wordpress-email-scraper-fast/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
