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

📧 eBay Email Scraper extracts seller email addresses from eBay listings & profiles. 🚀 Automate lead generation, outreach, and market research with reliable data. ✅ Great for sales teams, agencies & researchers. ⚡ Fast, efficient, SEO-ready.

- **URL**: https://apify.com/scrapepilotapi/ebay-email-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (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 $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

### **Social Media** Email Scraper 📱

The Ebay Email Scraper allows users to **extract** a variety of **data** points from Ebay accounts. This includes publicly available email addresses, seller names, and other relevant **contact** details.

The tool is designed to gather **data** in a structured format, making it easy to analyze and utilize for business purposes. Users can **extract** **data** from multiple Ebay accounts simultaneously, saving time and effort.

The scraper is optimized to ensure accuracy and reliability in the **data** it collects. It is a valuable resource for businesses looking to connect with Ebay sellers or analyze market trends.

The **extract**ed **data** can be used for outreach campaigns, customer relationship management, or competitive analysis.

Ebay Email Scraper is a powerful tool designed to help users extract email addresses from Ebay accounts efficiently and accurately. It simplifies the process of gathering contact information from Ebay sellers and businesses for legitimate purposes.

With the Ebay Email Scraper, users can save time and resources by automating the data collection process. This tool is ideal for businesses and individuals looking to connect with Ebay sellers or gather contact details for outreach campaigns.

The Ebay Email Scraper ensures data accuracy and provides only publicly available information in compliance with legal and ethical standards. It is an essential tool for anyone needing to extract emails from Ebay accounts without manual effort.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Publicly available email addresses of Ebay sellers. |
| Seller names | The names of Ebay sellers associated with the accounts. |
| Store names | Names of the Ebay stores operated by the sellers. |
| Contact details | Additional contact information provided by the sellers. |
| Product categories | Categories of products sold by the Ebay accounts. |
| Location information | Geographical location details of the sellers, if available. |
| Ratings and reviews | Feedback and ratings associated with the Ebay sellers. |
| Listing URLs | Links to the sellers' product listings on Ebay. |

### Key Features of **Social Media** Email Scraper

Here are the **standout features** that make the **Social Media** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Extracts publicly available email addresses from Ebay accounts with high accuracy
- ⭐ Supports bulk scraping of multiple Ebay accounts simultaneously
- ⭐ Provides structured and organized data output for easy analysis
- ⭐ Ensures compliance with legal and ethical data collection standards
- ⭐ Offers user-friendly interface for seamless operation and navigation
- ⭐ Automates data collection to save time and reduce manual effort
- ⭐ Includes advanced filtering options to target specific seller profiles
- ⭐ Compatible with various operating systems and devices
- ⭐ Delivers fast and reliable results for efficient data gathering
- ⭐ **Regular**ly updated to ensure compatibility with Ebay platform changes
- ⭐ Provides detailed logs and reports for transparency and tracking
- ⭐ Offers customizable settings to meet specific user requirements

### How to use **Social Media** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Social Media** emails today:

1. ✅ Download and install the Ebay Email Scraper software on your device
2. ✅ Launch the application and **log in** with your credentials
3. ✅ Enter the Ebay account URLs or keywords you want to scrape data from
4. ✅ **Configure** the scraping settings including filters and output format
5. ✅ **Start** the scraping process by clicking the **Start** button
6. ✅ Monitor the progress of the scraping process in the dashboard
7. ✅ Once the scraping is complete download the extracted data file
8. ✅ **Review** the data to ensure accuracy and completeness
9. ✅ Use the extracted data for your intended purposes such as outreach or analysis
10. ✅ Save your scraping configurations for future use
11. ✅ Log out of the application to secure your account
12. ✅ Contact support if you encounter any issues during the process

### Use Cases 🎯

Lead Generation
🎯 Extract email addresses of Ebay sellers for outreach campaigns
🎯 Build a database of potential leads for your business

Market Research
🎯 **Analyze** seller profiles to understand market trends on Ebay
🎯 Gather data on product categories and pricing strategies

Customer Relationship Management
🎯 **Collect** contact details to enhance customer engagement
🎯 **Use** the data to personalize communication with Ebay sellers

Competitive Analysis
🎯 Monitor competitor activities by analyzing their seller profiles
🎯 **Identify** top-performing sellers and their strategies

Business Expansion
🎯 **Find** new sellers to partner with for your business growth
🎯 Expand your network by connecting with Ebay sellers

### Why choose us? 💎

Our Ebay Email Scraper is designed to provide users with a **reliable** and efficient tool for extracting email addresses and other contact details from Ebay accounts. We prioritize accuracy and ensure that the data collected is structured and ready for use.

Our tool is **user-friendly** and requires no technical expertise, making it accessible to everyone. We stay updated with the latest developments on the Ebay platform to ensure compatibility and optimal performance.

Our software is built with compliance in mind, adhering to all legal and ethical standards for data collection. We offer excellent customer support to assist users with any questions or issues they may encounter.

By choosing our Ebay Email Scraper, you gain access to a powerful tool that simplifies data collection and helps you achieve your business goals. Whether you are conducting market research, generating leads, or analyzing competitors, our scraper is the perfect solution for your needs.

### **Social Media** Email Scraper Scalability 📈

The Ebay Email Scraper is designed to handle data extraction tasks of any scale, from small projects to **large-scale** operations. It supports bulk scraping, allowing users to extract data from multiple Ebay accounts simultaneously.

This makes it an ideal choice for businesses of all sizes, from startups to large enterprises. The tool is optimized for speed and efficiency, ensuring that even large datasets can be processed quickly.

Our scalable infrastructure ensures that the scraper performs reliably, regardless of the workload. Users can customize the scraping settings to meet their specific requirements, making it a versatile solution for various use cases.

With our Ebay Email Scraper, you can scale your data collection efforts without compromising on accuracy or performance.

### **Social Media** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Social Media** is **legal** as long as you follow **ethical** and **compliant** practices. The **Social Media** Email Scraper extracts only **publicly available** information from **public** **Social Media** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** that the data you collect is publicly available on Ebay
⚖️ **Do not** use the scraper to access private or restricted information
⚖️ Comply with all applicable data protection and privacy laws in your region
⚖️ **Obtain** consent from individuals before using their contact information for marketing purposes
⚖️ **Do not** use the scraper for spamming or other unethical practices
⚖️ **Avoid** overloading Ebay servers by adhering to responsible scraping practices
⚖️ Regularly review Ebays terms of service to ensure compliance
⚖️ **Use** the scraper only for legitimate and ethical purposes

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Ebay Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Social Media",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Social Media) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Social Media",
    "keyword": "Ebay Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Social Media as the source |
| keyword | Keyword that triggered the result (Ebay Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Social Media profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the Ebay **Email Scraper**?

The Ebay Email Scraper is a tool that extracts **publicly available** email addresses and other contact details from Ebay accounts.

#### Is the Ebay **Email Scraper** **legal** to use?

**Yes**, the scraper is designed to comply with legal and ethical standards by only collecting **publicly available** information.

#### Can I use the Ebay **Email Scraper** for bulk data **extract**ion?

**Yes**, the tool supports bulk scraping and can handle multiple Ebay accounts simultaneously.

#### What data can I **extract** using the Ebay **Email Scraper**?

You can extract email addresses, seller names, store names, contact details, product categories, location information, ratings, and listing URLs.

#### Is the Ebay **Email Scraper** easy to use?

**Yes**, the scraper features a **user-friendly** interface and requires no technical expertise to operate.

#### Can I customize the scraping settings?

**Yes**, the tool allows users to configure filters and output formats to meet their specific needs.

#### How accurate is the data collected by the Ebay **Email Scraper**?

The scraper is optimized for high accuracy, ensuring reliable and structured data output.

#### Does the Ebay **Email Scraper** support updates?

**Yes**, the tool is regularly updated to ensure compatibility with Ebay platform changes.

#### What formats are available for the **extract**ed data?

The extracted data can be downloaded in various formats, such as **CSV** or **JSON**, for easy analysis.

#### Is **customer support** available for the Ebay **Email Scraper**?

**Yes**, we provide excellent customer support to assist users with any questions or issues.

#### Can I use the Ebay **Email Scraper** for competitive analysis?

**Yes**, the scraper can help you analyze competitor profiles and strategies on Ebay.

#### Is the Ebay **Email Scraper** compatible with all operating systems?

**Yes**, the tool is compatible with various operating systems, including Windows and macOS.

#### What is the output format of the **extract**ed data?

The output is structured and can be customized to suit your requirements, such as **CSV** or **JSON**.

#### Can I scrape data from **specific** Ebay categories?

**Yes**, the tool includes **filtering** options to target specific product categories or seller profiles.

#### How do I ensure compliance while using the Ebay **Email Scraper**?

Follow all legal guidelines, collect only **publicly available** data, and avoid unethical practices like spamming.

# Actor input Schema

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

List of keywords to search for on Ebay (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Ebay profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Ebay",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilotapi/ebay-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilotapi/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 & profiles. 🚀 Automate lead generation, outreach, and market research with reliable data. ✅ Great for sales teams, agencies & researchers. ⚡ Fast, efficient, SEO-ready.",
        "version": "0.1",
        "x-build-id": "64NfjRCdMKpKn42mj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~ebay-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-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/scrapepilotapi~ebay-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-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/scrapepilotapi~ebay-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-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": "List of keywords to search for on Ebay (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Ebay profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Ebay"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Ebay"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```