# Etsy Email Scraper (`scrapeengine/etsy-email-scraper`) Actor

📧 Etsy Email Scraper extracts seller contacts emails from Etsy listings to streamline outreach. 🛠️ Helps with lead gen, B2B research & marketing. 🚀 Save time, improve accuracy, and grow your customer pipeline.

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

### **Etsy** Email Scraper 📱

**Etsy** Email Scraper provides users with the ability to **extract** essential **contact** information from **Etsy** sellers. This includes email addresses, seller names, and store details, enabling businesses to build comprehensive email **data**bases.

The tool also retrieves additional seller **data** such as product categories, store URLs, and location details. With this information, users can effectively target sellers for marketing campaigns or collaboration opportunities.

The **Etsy** email harvesting tool ensures **data** accuracy and relevance, making it easier to organize and utilize the **extract**ed information. This software is designed to provide a seamless experience for users looking to scrape **Etsy** **emails** efficiently and ethically.

Etsy Email Scraper is an advanced tool designed to help users extract contact information from Etsy sellers efficiently. It simplifies the process of gathering seller emails for marketing and communication purposes.

With the Etsy email extraction tool, businesses can save time and effort by automating the collection of seller contact details. This tool is ideal for creating targeted email lists and expanding your network.

Scraping Etsy seller emails allows users to connect directly with vendors for collaborations, inquiries, or promotional campaigns. This ensures a streamlined approach to building professional relationships.

### 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 |
| --- | --- |
| Seller email | Extracts the email address associated with the seller's account. |
| Seller name | Retrieves the name of the Etsy seller for personalized communication. |
| Store name | Collects the name of the seller's Etsy store for identification. |
| Store URL | Captures the direct link to the seller's Etsy store. |
| Product categories | Identifies the categories of products sold by the seller. |
| Location details | Extracts the geographical location of the seller's store. |
| Store description | Retrieves the seller's store description for additional context. |
| Contact preferences | Provides information on seller communication preferences, if available. |

### Key Features of **Etsy** Email Scraper

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

- ⭐ **Automated** extraction of seller emails from **Etsy** for increased efficiency
- ⭐ Supports scraping of multiple data points including store names and URLs
- ⭐ User-friendly interface for quick and easy setup of scraping tasks
- ⭐ **Customizable** filters to target specific sellers or product categories
- ⭐ Ensures compliance with ethical data collection practices and guidelines
- ⭐ Provides detailed reports and organized email lists for convenience
- ⭐ Offers scalable solutions for businesses of all sizes and needs
- ⭐ **Advanced** error handling to ensure accurate and reliable data extraction
- ⭐ **Regular** updates to maintain compatibility with **Etsy**s platform changes
- ⭐ **Secure** and encrypted data handling to protect user and seller information
- ⭐ **Fast** processing speeds for large-scale email scraping projects
- ⭐ **Comprehensive** customer support for troubleshooting and assistance

### How to use **Etsy** Email Scraper 🚀

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

1. ✅ Download and install the **Etsy** Email Scraper software on your device
2. ✅ Log in to your account or create a new one to access the tool
3. ✅ Set up your scraping preferences by selecting desired data points such as emails and store names
4. ✅ Use filters to narrow down your search to specific sellers or product categories
5. ✅ Initiate the scraping process and monitor the progress through the dashboard
6. ✅ Once the scraping is complete review the extracted data for accuracy
7. ✅ **Export** the data to your preferred format such as CSV or Excel files
8. ✅ Organize the email list for marketing or communication purposes
9. ✅ Repeat the process as needed for additional sellers or updated information
10. ✅ Ensure compliance with **Etsy**s terms and conditions during data usage

### Use Cases 🎯

Marketing Campaigns
🎯 Create targeted email lists for promotional campaigns
🎯 Reach out to **Etsy** sellers with personalized offers

Business Collaboration
🎯 Connect with sellers for partnership opportunities
🎯 **Identify** potential vendors for product sourcing

Market Research
🎯 **Analyze** seller data to understand market trends
🎯 Gather insights on popular product categories

Networking
🎯 Build relationships with **Etsy** sellers for future projects
🎯 Expand your professional network within the **Etsy** community

### Why choose us? 💎

Our **Etsy** Email Scraper stands out as the **best** **Etsy** email scraping software due to its efficiency and reliability. It is designed to simplify the process of extracting seller contact information, saving users time and effort.

The tool supports a wide range of data points, including seller emails, store names, and product categories, ensuring comprehensive results. With **advanced** features like customizable filters and **scalable** solutions, it caters to businesses of all sizes.

We prioritize data accuracy and ethical practices, ensuring compliance with **Etsy**'s guidelines. Our software is **regular**ly updated to maintain compatibility with **Etsy**'s platform changes, offering users a seamless experience.

Additionally, we provide robust customer support to assist users with any challenges they may face. Choosing our **Etsy** email extraction tool guarantees high-quality results and secure data handling.

Whether you need to scrape **Etsy** seller emails for marketing, research, or networking, our tool is the ideal solution.

### **Etsy** Email Scraper Scalability 📈

**Etsy** Email Scraper is designed to handle projects of various sizes, making it suitable for both small businesses and large enterprises. Its scalable architecture ensures **efficient** performance even when processing **extensive** data sets.

Users can customize their scraping preferences to target specific sellers or categories, allowing flexibility in data collection. The tool's fast processing speeds enable users to complete **large-scale** email scraping tasks within a short timeframe.

With regular updates and **advanced** error handling, it adapts **seamless**ly to **Etsy**'s platform changes. Whether you need to scrape a few seller emails or build a comprehensive **Etsy** email database, our software provides reliable and scalable solutions.

It is the best **Etsy** email scraper for businesses looking to grow their reach while maintaining compliance with ethical guidelines.

### **Etsy** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Etsy**s terms of service when using the **Etsy** Email Scraper
⚖️ **Do not** use the tool to collect data for unsolicited marketing or spam campaigns
⚖️ Respect seller privacy and avoid scraping sensitive information without consent
⚖️ **Use** the extracted data ethically and in accordance with applicable laws and regulations
⚖️ **Avoid** sharing or selling the scraped data to third parties without proper authorization
⚖️ Regularly review **Etsy**s policies to ensure continued compliance during data collection
⚖️ **Do not** attempt to bypass security measures on **Etsy**s platform while scraping data
⚖️ **Use** the tool responsibly and prioritize ethical practices in all scraping activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Etsy Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Etsy",
  "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 (Etsy) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Etsy",
    "keyword": "Etsy 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 Etsy as the source |
| keyword | Keyword that triggered the result (Etsy Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Etsy profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Etsy **Email Scraper**?

Etsy Email Scraper is a tool designed to extract seller contact information from Etsy efficiently.

#### Can I scrape Etsy seller emails for marketing purposes?

**Yes**, you can use the tool to create targeted email lists for marketing campaigns, provided you comply with Etsy's guidelines.

#### Is the Etsy email **extract**ion tool easy to use?

**Yes**, the tool features a **user-friendly** interface for quick and easy setup.

#### What data can I **extract** with the Etsy contact scraper?

You can extract seller **emails**, store names, URLs, product categories, and location details.

#### Is the tool compatible with Etsy's platform updates?

**Yes**, the software is regularly updated to ensure compatibility with Etsy's changes.

#### How do I ensure ethical use of the scraped data?

Follow Etsy's terms of service and avoid using the data for unsolicited marketing or spam.

#### Can I customize the scraping preferences?

**Yes**, the tool allows you to apply filters to target specific sellers or product categories.

#### Is the Etsy email scraping software scalable?

**Yes**, it is designed to handle projects of various sizes, from small tasks to large-scale scraping.

#### Does the tool provide accurate results?

**Yes**, it ensures data accuracy through advanced error handling mechanisms.

#### What formats can I **export** the scraped data to?

You can export the data to formats like **CSV** or Excel files for easy organization.

#### Does the tool offer **customer support**?

**Yes**, we provide comprehensive customer support to assist with any challenges.

#### Can I scrape seller contact preferences?

**Yes**, the tool can extract seller communication preferences if available.

#### Is the tool **secure**?

**Yes**, it uses encryption to protect user and seller information during data handling.

#### Can I use the tool for market research?

**Yes**, the tool is ideal for analyzing seller data and understanding market trends.

#### How fast is the Etsy **Email Scraper**?

The tool offers fast processing speeds for efficient data extraction, even for large-scale projects.

# Actor input Schema

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

List of keywords to search for on Etsy (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Etsy 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": "Etsy",
  "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("scrapeengine/etsy-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("scrapeengine/etsy-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 scrapeengine/etsy-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Email Scraper",
        "description": "📧 Etsy Email Scraper extracts seller contacts emails from Etsy listings to streamline outreach. 🛠️ Helps with lead gen, B2B research & marketing. 🚀 Save time, improve accuracy, and grow your customer pipeline.",
        "version": "0.1",
        "x-build-id": "zrqlP49smaeNp0kOe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~etsy-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-etsy-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/scrapeengine~etsy-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-etsy-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/scrapeengine~etsy-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-etsy-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 Etsy (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Etsy profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Etsy"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Etsy"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```