# Gumroad Email Scraper (`api-empire/gumroad-email-scraper`) Actor

Automate email extraction from Gumroad with Gumroad Email Scraper. The actor scans creator pages and external links to pull available contact emails into structured datasets for CRM enrichment.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### **Gumroad** Email Scraper 📱

The **Gumroad** Email Scraper allows you to **extract** a wide range of **data** from the **Gumroad** platform. This includes essential **contact** details, user information, and other relevant **data** points.

By using this tool, you can gather structured and organized **data** for marketing, research, or business development purposes. The scraper is designed to **extract** **data** efficiently while maintaining accuracy and reliability.

It supports various use cases, such as email list generation, customer analysis, and outreach campaigns. With its advanced algorithms, the **Gumroad** Email Scraper ensures that the **extract**ed **data** is up-to-date and relevant.

This tool is ideal for businesses, marketers, and researchers who need to access **Gumroad** user information quickly and effectively.

Gumroad Email Scraper is an advanced tool designed to help you extract valuable email data from Gumroad in an efficient and automated manner. This tool is ideal for businesses and individuals looking to streamline their email collection process on the Gumroad platform.

With the Gumroad Email Scraper, you can save time and effort by automating the extraction of contact information from Gumroad. It is a reliable solution for generating email lists and accessing user data for marketing or research purposes.

Gumroad is a popular platform for creators to sell digital products, making it a rich source of contact information for targeted outreach. Our scraper ensures you can extract this data quickly and accurately.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses of Gumroad users for outreach and marketing purposes. |
| User names | Collect the names of Gumroad users associated with their accounts. |
| Product details | Retrieve information about products listed by Gumroad users. |
| Profile URLs | Get direct links to user profiles on the Gumroad platform. |
| Social media links | Extract social media links shared on Gumroad profiles. |
| Sales data | Collect sales-related data such as product pricing and availability. |
| User descriptions | Scrape user-provided descriptions or bios from their profiles. |
| Contact forms | Identify and extract contact form links or details shared by users. |

### Key Features of **Gumroad** Email Scraper

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

- ⭐ Automates the extraction of email addresses and user data from **Gumroad**
- ⭐ Supports bulk data scraping for large-scale projects
- ⭐ **Customizable** filters to target specific user profiles or product categories
- ⭐ Ensures data accuracy with advanced parsing algorithms
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Exports data in multiple formats such as CSV or JSON for convenience
- ⭐ Complies with ethical data scraping practices and guidelines
- ⭐ Offers real-time scraping capabilities for up-to-date information
- ⭐ **High**ly scalable to handle small or large data extraction tasks
- ⭐ Includes detailed logs and error handling for efficient troubleshooting

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

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

1. ✅ **Sign up** for the **Gumroad** Email Scraper and download the tool
2. ✅ Install the scraper on your preferred device following the provided instructions
3. ✅ Log in to the scraper using your account credentials
4. ✅ Enter the target **Gumroad** URLs or keywords for data extraction
5. ✅ **Configure** the scraping parameters such as filters and data types
6. ✅ **Start** the scraping process and monitor progress in real-time
7. ✅ **Review** the extracted data in the tools dashboard for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or JSON
9. ✅ Use the extracted data for your marketing or research purposes
10. ✅ Regularly update the scraper to access new features and improvements

### Use Cases 🎯

Email Marketing Campaigns
🎯 Generate targeted email lists for your marketing campaigns
🎯 Reach out to **Gumroad** users with personalized email offers

Market Research
🎯 **Analyze** **Gumroad** user data to identify market trends
🎯 Gather insights on popular products and user preferences

Business Development
🎯 Build a database of potential collaborators or clients from **Gumroad**
🎯 **Identify** key influencers in your industry using **Gumroad** data

Competitor Analysis
🎯 Monitor competitor activity and product offerings on **Gumroad**
🎯 Extract data to benchmark your performance against competitors

### Why choose us? 💎

Our **Gumroad** Email Scraper stands out as the **best** **Gumroad** scraper for its efficiency, accuracy, and ease of use. We prioritize user satisfaction by offering a tool that is both powerful and intuitive.

The scraper is designed to handle a wide range of data extraction tasks, from email harvesting to detailed user analysis. By using our tool, you can save time and resources while achieving your data collection goals.

Our focus on ethical scraping practices ensures that you can use the **Gumroad** Email Scraper with confidence. We also provide excellent customer support to assist you with any questions or issues.

Whether you are a marketer, researcher, or business owner, our scraper is tailored to meet your needs. With **advanced** features and scalability, it is the ideal solution for extracting data from **Gumroad** efficiently and effectively.

### **Gumroad** Email Scraper Scalability 📈

The **Gumroad** Email Scraper is built to handle projects of any size, making it a highly scalable solution. Whether you need to extract data from a few profiles or thousands, the scraper can adapt to your requirements.

Its **advanced** algorithms ensure consistent performance even with **large-scale** data extraction tasks. The tool is optimized for speed and reliability, allowing you to complete your projects **efficient**ly.

With **customizable** settings, you can tailor the scraping process to suit your specific needs. This scalability makes the **Gumroad** Email Scraper suitable for businesses, researchers, and marketers alike.

It is designed to grow with your demands, ensuring that you always have access to the data you need.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Gumroad**s terms of service when using the scraper
⚖️ **Do not** use the tool to collect data for illegal or unethical purposes
⚖️ **Obtain** user consent where required before using their contact information
⚖️ **Avoid** scraping sensitive or private data from **Gumroad** profiles
⚖️ **Use** the scraper responsibly to prevent overloading **Gumroad**s servers
⚖️ Regularly review legal and ethical guidelines for data scraping
⚖️ **Do not** resell or distribute scraped data without proper authorization
⚖️ **Ensure** that your data usage complies with relevant privacy laws and regulations

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

The Gumroad Email Scraper is a tool designed to extract email addresses and other data from the Gumroad platform.

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

**Yes**, the scraper features a **user-friendly** interface and clear instructions for setup and operation.

#### What data can I **extract** with this tool?

You can extract email addresses, user names, product details, profile URLs, and more.

#### Is the scraper compliant with **legal** guidelines?

**Yes**, the Gumroad Email Scraper is designed to adhere to ethical and legal data scraping practices.

#### Can I use the scraper for bulk data **extract**ion?

**Yes**, the tool supports bulk data scraping for large-scale projects.

#### What formats are available for **export**ing data?

You can export the data in formats such as **CSV** or **JSON**.

#### Does the scraper work in real-time?

**Yes**, the Gumroad Email Scraper supports real-time data scraping for up-to-date information.

#### Is **customer support** available for this tool?

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

#### Can I customize the scraping parameters?

**Yes**, the scraper allows for customizable filters and settings to target specific data.

#### Is the Gumroad **Email Scraper** scalable?

**Yes**, the tool is **highly scalable** and can handle projects of any size.

#### Can I scrape **private** data using this tool?

**No**, the scraper is designed to avoid sensitive or private data to comply with ethical guidelines.

#### How often is the tool updated?

The Gumroad Email Scraper is regularly updated to include new features and improvements.

#### Is there a free trial available?

Please check our website for information on free trials or demo versions.

#### Can I use the scraper for competitor analysis?

**Yes**, the tool can help you monitor competitor activity and product offerings on Gumroad.

#### What are the system requirements for the scraper?

The system requirements are detailed in the installation guide provided with the tool.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumroad Email Scraper",
        "description": "Automate email extraction from Gumroad with Gumroad Email Scraper. The actor scans creator pages and external links to pull available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "f1JghgfZQAUYpHRmp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~gumroad-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-gumroad-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/api-empire~gumroad-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-gumroad-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/api-empire~gumroad-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-gumroad-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 Gumroad (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Gumroad profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Gumroad"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Gumroad"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```