# Ebay Email Scraper (`scraperoka/ebay-email-scraper`) Actor

📧 eBay Email Scraper extracts seller email addresses from eBay listings fast and accurately. Perfect for lead gen, B2B outreach, and market research—save time and boost productivity. 🚀 Extract. Organize. Convert.

- **URL**: https://apify.com/scraperoka/ebay-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **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

### eBay Email Scraper 🎯

Manually hunting down seller contact emails one by one wastes hours you don’t have. **eBay Email Scraper** finds emails from eBay using your keywords and email-domain filters, turning scattered public contact info into a structured dataset. This eBay email scraper tool is built for marketers, recruiters, and growth teams who want faster outreach list building, producing thousands of email records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "juicer",
  "title": "Acme Juicer Deals - Contact",
  "description": "For business inquiries, email sales@acmejuicers.com. Shipping available worldwide.",
  "url": "https://example.com/some-public-page",
  "email": "sales@acmejuicers.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to discover this email, so you can segment leads later |
| `title` | string | The result title connected to the contact information for quick context |
| `description` | string | The extracted surrounding text where the email was found (useful for validation and notes) |
| `url` | string | The source link associated with the extracted data |
| `email` | string | The email address that matches your selected domain filters |
| `error_message` | string | Error details when something goes wrong (if returned by your run handling) |
| `status` | string | Run/record state you can use to identify successful vs. problematic entries |
| `success` | boolean | Indicates whether the record was captured successfully (when available in your run output) |
| `charged_event_name` | string | The dataset write event name used when results are pushed (for run accounting) |
| `platform` | string | Platform context for your pipeline (this actor is focused on eBay) |
| `location` | string | Optional location filter value used during the run (if provided) |
| `customDomains` | array | Which email domains were used to filter matching email addresses |
| `proxyConfiguration` | object | Proxy settings you provided for reliable scraping at scale |

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

***

### Why eBay Email Scraper?

There are a lot of ways to pull data from eBay for outreach—here’s what sets **eBay Email Scraper** apart.

#### Built for email-domain targeting

You control which email addresses qualify via `customDomains`, so the tool focuses on emails that match the domains you care about. This makes your results cleaner than general eBay contact email scraping.

#### Keyword-based lead discovery

Run searches using your `keywords` and (optionally) `location` to guide the dataset toward the right eBay sellers and listings. This makes it a practical eBay seller email finder for lead generation email scraper workflows.

#### Deduplicated results for cleaner lists

The actor tracks `seen_emails` during a run and avoids pushing the same email multiple times. That reduces noisy duplicates when you scrape eBay emails in bulk.

#### Resilient scraping with proxy support

You can configure `proxyConfiguration` for this actor to improve reliability on larger runs. If no emails are found under your chosen proxy settings, it can fall back to an alternative proxy approach for better coverage.

***

### Configuring Your Run

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

```json
{
  "keywords": ["juicer", "wallet"],
  "location": "United States",
  "platform": "eBay",
  "customDomains": ["@gmail.com", "@example.com"],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords the actor uses to search for relevant eBay contacts |
| `location` | ⬜ | Optional location text to help filter results toward a specific geography |
| `platform` | ⬜ | Platform selector (this actor is configured for `eBay`) |
| `customDomains` | ⬜ | Email domain filters; only emails matching these domains are collected |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run |
| ↳ `proxy support` | ⬜ | Enables routing through Apify Proxy when set in your proxy configuration |

***

### Core Capabilities

#### Keyword and domain filters that match outreach needs

**eBay Email Scraper** uses your `keywords` alongside `customDomains` so the dataset is geared toward the emails you want, not random matches. If you’re running an eBay user email extractor workflow, this keeps your lead list relevant.

#### Structured output you can act on immediately

Each pushed result includes the fields you need to review and verify: `keyword`, `title`, `description`, `url`, and `email`. That makes extract emails from eBay listings easy to review before you sync into your CRM.

#### Deduplication across the run

Within a single run, the actor prevents duplicates by remembering already-seen emails. This helps automated eBay email harvesting stay usable even when multiple keywords lead to overlapping sources.

#### Resilience with proxy configuration and fallback behavior

You can provide `proxyConfiguration` to improve reliability, and the actor includes fallback logic when it doesn’t find emails with your initial proxy setup. This supports more consistent coverage in eBay contact email scraping jobs.

#### Automation-friendly dataset writing

Results are collected and pushed to the Apify dataset as the run completes, making it easy to export or automate downstream steps. For teams building an eBay lead generation email scraper pipeline, this keeps data handling straightforward.

***

### Who Gets the Most Out of This

Here's how different teams put **eBay Email Scraper** to work:

**Growth and lead generation marketers** — They run the actor with campaign keywords and target domains, then export the resulting email list to their outreach stack, saving hours of manual prospecting while focusing on qualified inboxes.

**Sales development and recruiting teams** — They use keyword-driven scraping to build a contact pool for outreach to eBay sellers and related businesses, then segment leads by `keyword` to speed up prioritization.

**Data analysts and researchers** — They use the structured output fields (`title`, `description`, and `url`) to audit sources, quantify coverage by keyword, and evaluate email-domain match rates across datasets.

**Automation specialists (technical)** — They trigger the actor via the Apify platform and connect the dataset export to their workflows, keeping eBay email scraping software results ready for ETL or CRM imports.

**Compliance-minded operators** — They rely on user-provided `customDomains` and the presence of a source `url` to support internal review processes before any outreach.

***

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

No coding needed. Here's how to run eBay Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **eBay Email Scraper**.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `proxyConfiguration`.
3. **Configure proxy settings** — choose your preferred `proxyConfiguration` settings to improve reliability for your run.
4. **Hit Run and watch the live log** — monitor progress and check for any scraping issues.
5. **View results in the dataset tab** — review extracted records containing `email`, `url`, and the related context fields.
6. **Export as JSON, CSV, or Excel** — download your dataset directly from the Apify dashboard.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **eBay Email Scraper** plugs directly into your existing workflow.

You can export your dataset formats directly from the Apify dataset tab, including **JSON**, **CSV**, and **Excel**. This is ideal for anyone building find eBay seller email lists for spreadsheets, CRM imports, or reporting.

For automation and programmatic access, you can connect results via the Apify platform using **API access** (see [apify.com/docs/api](https://apify.com/docs/api)), and you can also integrate dataset outputs using common automation approaches such as webhooks and no-code tools like **Zapier** or **Make**. For deeper workflow details, refer to Apify’s documentation for integrations and scheduling.

***

### Pricing & Free Trial

eBay Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can use the free tier for several test runs, then scale using Apify’s pay-as-you-go compute model (billed per platform compute usage). For teams doing heavy, recurring eBay email scraping software jobs, Apify’s subscription plans may be available on the pricing page—check Apify for the latest plan details.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit resilience | Proxy support and reliability-focused configuration options |
| Scraping consistency | Fallback behavior when initial attempts don’t find emails |
| Data cleanliness | Deduplication of emails within a run to reduce noise |
| Error visibility | Returned records include context fields to help you review issues |
| Automation scale | Dataset output designed for batch processing and exports |

Limitations: This actor works only with publicly available sources. If matching emails are not present in the publicly available text for your selected `keywords` and `customDomains`, you may see fewer results.

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

***

### Frequently Asked Questions

#### Is there a free plan or trial for eBay Email Scraper?

Yes, Apify offers a free tier on the platform so you can run **eBay Email Scraper** with credits to test your workflow before scaling.

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

No. The actor is designed to scrape emails from publicly available data sources, without requiring an eBay login.

#### How accurate is the data extracted by eBay Email Scraper?

Accuracy depends on what contact information is publicly available for the pages the actor discovers. The output email values are extracted based on `customDomains` filtering, so matching is domain-driven.

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

Your results depend on how many relevant matches exist for your `keywords`, `location`, and `customDomains`. The actor also deduplicates by email during the run to avoid repeated entries.

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

Data freshness depends on when the pages are publicly accessible and how recently they were updated online. Each run collects whatever is available at the time you execute the actor.

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

You should review applicable laws and platform terms before using or storing harvested contact data. Use **publicly available data**, and ensure your usage complies with GDPR, CCPA, and any relevant regulations; it’s your responsibility to manage compliance.

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

Yes. You can export your dataset from the Apify dashboard in formats including **CSV** and **Excel**, and then import into tools like Google Sheets.

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

Yes. You can automate scheduled runs using Apify platform capabilities for recurring jobs—configure scheduling in your Apify workflow.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically using the Apify API—see [apify.com/docs/api](https://apify.com/docs/api).

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

If requests fail or no emails are found under certain conditions, you’ll see logging that explains what went wrong for that part of the run. The actor continues collecting results where possible and pushes gathered outputs at the end.

***

### Need Help or Have a Request?

Got a question about **eBay Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like “keyword-based discovery improvements” and “webhook on completion” to make automated eBay email harvesting smoother.

***

### Disclaimer & Responsible Use

*eBay Email Scraper is the fastest, most reliable way to build an eBay seller contact email dataset from publicly available sources — start your free run today.*

**publicly available data** only: the actor does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, applicable platform ToS, and any other relevant regulations when storing or using the extracted data. 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 to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

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

List of custom email domains

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "juicer",
    "wallet"
  ],
  "location": "",
  "platform": "eBay",
  "customDomains": [
    "@gmail.com"
  ]
}
```

# 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": [
        "juicer",
        "wallet"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/ebay-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "juicer",
        "wallet",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/ebay-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "juicer",
    "wallet"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/ebay-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ebay Email Scraper",
        "description": "📧 eBay Email Scraper extracts seller email addresses from eBay listings fast and accurately. Perfect for lead gen, B2B outreach, and market research—save time and boost productivity. 🚀 Extract. Organize. Convert.",
        "version": "0.0",
        "x-build-id": "g2O7Wa6Tg7cMZu2oE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~ebay-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-ebay-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~ebay-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-ebay-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~ebay-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-ebay-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "juicer",
                            "wallet"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "eBay"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "eBay"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
