# Buy Me A Coffee Email Scraper Fast Advanced And Cheapest (`scraperoka/buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Extract emails fast with Buy Me A Coffee Email Scraper (Fast, Advanced & Cheapest). Get accurate leads quickly for outreach, sales & marketing. Streamline prospecting, boost conversions, and save time—start today! ✅

- **URL**: https://apify.com/scraperoka/buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $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

### Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest 🎯

Manually hunting for contact emails wastes hours you could spend building outreach lists. **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Buy me a coffee based on your keywords and domain filters—ideal for marketers, recruiters, and growth teams. Use Buy Me A Coffee email scraper for lead generation and contact email harvesting software workflows, and collect thousands of potential contacts in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Buy me a coffee.com",
  "keyword": "founder",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "founder@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network label used for the record |
| `keyword` | string | Which keyword from your input produced this lead |
| `title` | string | The extracted result title text (or a fallback like “No title”) |
| `description` | string | The extracted page snippet text (or “No data” when empty) |
| `url` | string | The extracted result URL (or “No URL” when unavailable) |
| `email` | string | The email address extracted and pushed to the dataset |

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

***

### Why Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull contact data from public web sources—here's what sets **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** apart.

#### Fast scraping at controlled scale

This Buy Me A Coffee email scraper is designed to move through keyword and domain combinations efficiently while keeping your run bounded by your `maxEmails` goal and time constraints.

#### Keyword + domain targeting for better signal

You can focus results using your `keywords` list and `customDomains` (like `@gmail.com` or `@yahoo.com`) so the Buy Me A Coffee subscriber email extractor returns emails that match your outreach preferences.

#### Deduplicated emails throughout the run

The actor tracks emails it has already seen during the run, preventing duplicate pushes and helping you build cleaner Buy Me A Coffee email list builder exports.

#### Resilient runs with progress saving

If the run stops or you need to resume, the actor saves progress so it can continue from where it left off using its stored cursor state and already-seen emails.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries the actor uses to find relevant Buy Me A Coffee leads to extract emails from |
| `location` | ⬜ | Filters results by a location string you provide |
| `customDomains` | ⬜ | Restricts extracted emails to the domains you list (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Stops the scraper after collecting this many unique emails (helpful for cost control) |

***

### Core Capabilities

#### Email extraction from publicly available sources

The actor extracts email addresses associated with Buy me a coffee results using the keywords and your selected email domains.

#### Flexible input for lead targeting

You control how broad or narrow the search is by adjusting `keywords`, optionally adding a `location`, and setting `customDomains` to focus on the email providers you care about—ideal for advanced Buy Me A Coffee email scraper use cases.

#### Stops safely using `maxEmails`

If you set `maxEmails`, the scraper will stop once the unique email limit is reached, helping you run faster and avoid spending time chasing diminishing returns.

#### Progress saving for resumable runs

The actor persists progress (including a cursor and a list of seen emails) so you can resume without losing all prior work—useful for automated Buy Me A Coffee email scraper workflows.

#### Dataset-ready, structured output

Each extracted lead is pushed into the Apify dataset with fields like `keyword`, `url`, and `email`, making it straightforward to feed into downstream lead generation processes.

***

### Who Gets the Most Out of This

Here’s how different teams put **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** to work:

**Growth and performance marketers** — Use targeted keywords (like roles) and email-provider domains to build a cleaner prospect list faster, so outreach teams can start campaigns with more relevant contacts and fewer manual searches.

**Recruiters and talent sourcers** — Run bulk email harvesting software-style workflows to quickly collect contact emails tied to creator/business pages, then export the dataset as a ready-to-import list for follow-ups.

**Sales development teams** — Combine `maxEmails` with focused `customDomains` to cap spend during testing, then iterate on keywords to expand coverage when the first lists produce replies.

**Freelance researchers and analysts** — Use the structured dataset fields (`keyword`, `url`, `email`) to analyze coverage by keyword, export results, and build reproducible lead generation tool pipelines for studies and reports.

**Automation and integration specialists** — Trigger runs and ingest results programmatically via the Apify API, then connect the exported dataset to your CRM or marketing stack for continuous lead collection.

***

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

No coding needed. Here's how to run **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** from start to finish:

1. **Open the actor on Apify** — go to the actor page on Apify: https://console.apify.com
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails` in the input editor
3. **Configure proxy settings** — if prompted, enable proxy options for better reliability on larger runs
4. **Hit Run and watch the live log** — monitor progress as the actor pushes extracted leads into the dataset
5. **View results in the dataset tab** — open the dataset titled “Scraped Leads” to inspect extracted records
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dataset tab for your outreach or analysis workflow

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow.

Export your dataset in standard formats from the Apify dashboard, including JSON, CSV, and Excel. From there, you can load it into spreadsheets, CRMs, or other reporting tools.

You can also connect the actor to automation workflows using Apify’s API capabilities for programmatic access, and use no-code tools like Zapier or Make to move results to downstream systems. For deeper setup details, refer to Apify documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

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

You can start with small test runs using the free tier and scale up when you’re ready. Final costs depend on your Apify usage and compute—check the Apify pricing page for the latest details, then choose a plan that matches your scraping volume. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting risk | Uses built-in reliability patterns and proxy support for stable scraping |
| Large keyword/domain coverage | Designed to iterate through combinations efficiently while respecting your `maxEmails` stopping point |
| Resuming interrupted runs | Saves progress so you can continue from the last cursor position and seen emails |
| Data pushed incrementally | Results are written to the dataset as they’re found |

Limitations: the actor extracts emails from publicly available sources and does not access private or login-gated content. If email addresses aren’t present in publicly available text for your chosen keywords/domains, you may collect fewer results.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes—Apify offers a free tier. You can use it for smaller test runs and evaluate output quality before scaling up.

#### Do I need to log in to Buy Me A Coffee to use this?

No. This actor extracts emails from publicly available sources without requiring account login.

#### How accurate is the data?

Accuracy depends on what’s publicly available in the source content. The actor extracts email addresses it detects and pushes them to the dataset, so the output reflects what the pages contain.

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

You control the total with the `maxEmails` input. The actor stops once the unique email limit is reached, up to the constraints of your plan.

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

Freshness depends on when the actor is run. Each run collects the emails that are publicly visible at that time and writes them to the dataset.

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

The actor only works with **publicly available data**. Compliance with GDPR, CCPA, platform terms, and any applicable laws is your responsibility based on how you store and use the extracted emails.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel from the dataset tab, then import into tools like Google Sheets or any spreadsheet-capable workflow.

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

Yes. You can schedule runs using Apify platform capabilities for automated recurring extraction.

#### Can I access this via API?

Yes. You can access actor run results programmatically via the Apify API. See https://apify.com/docs/api for details.

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

If errors occur during requests or pushing data, the actor uses logging and resiliency patterns and continues where possible. Your dataset contains the successfully pushed records, and progress saving helps with resumability.

***

### Need Help or Have a Request?

Got a question about **Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like improved keyword/domain controls and faster export-to-workflow options, and we actively maintain this actor based on user feedback. If you need a tailored setup for your use case, email us and we’ll help.

***

### Disclaimer & Responsible Use

*Buy Me A Coffee Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract publicly available contact emails for outreach — start your free run today.*

By using this actor, you agree that it extracts **publicly available data** only. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, and platform ToS when storing and using the extracted information. 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/buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest").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/buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest").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/buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Buy Me A Coffee Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Extract emails fast with Buy Me A Coffee Email Scraper (Fast, Advanced & Cheapest). Get accurate leads quickly for outreach, sales & marketing. Streamline prospecting, boost conversions, and save time—start today! ✅",
        "version": "1.0",
        "x-build-id": "uZnXY1j1pwkl4TnRG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest",
                "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~buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest",
                "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~buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-buy-me-a-coffee-email-scraper-fast-advanced-and-cheapest",
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
