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

Gumroad Email Scraper extracts publicly available email addresses from Gumroad creator profiles and linked pages. Build targeted contact lists for partnerships, promotions, and direct creator outreach at scale.

- **URL**: https://apify.com/scraper-engine/gumroad-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **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 is designed to **extract** key email-related **data** from **Gumroad** efficiently. It captures structured information that can be used for various business purposes, such as marketing, analysis, or customer communication.

The scraper ensures that all **extract**ed **data** is accurate and up-to-date, providing you with reliable insights. This tool is capable of **extract**ing **data** from **Gumroad** sellers, customers, or other relevant sources on the platform.

By automating the email **extract**ion process, it eliminates the need for manual **data** collection, saving time and effort. The **extract**ed **data** is presented in an organized format, making it easy to analyze and integrate into your workflows.

Gumroad Email Scraper is an advanced tool designed to help you extract valuable email data from Gumroad with ease and precision. It enables businesses and individuals to streamline their communication with Gumroad sellers and customers.

Using this Gumroad email extraction tool, you can gather contact information for marketing campaigns, customer outreach, or data analysis. It offers a reliable and automated way to collect emails without manual effort.

This email scraper for Gumroad sellers is ideal for generating targeted email lists quickly and efficiently. It ensures accurate data extraction while saving time and resources.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses of Gumroad sellers and customers for communication purposes. |
| Seller names | Retrieve the names of Gumroad sellers associated with the extracted emails. |
| Product information | Gather details about the products linked to the extracted email addresses. |
| Customer names | Identify the names of customers linked to the extracted email addresses. |
| Transaction details | Extract transaction-related data, such as purchase history, tied to emails. |
| Profile links | Collect links to Gumroad profiles associated with the extracted emails. |
| Date of activity | Retrieve timestamps of activities related to the extracted email data. |
| Location data | Extract location information tied to the email addresses, if available. |

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

- ⭐ **Automated** email extraction from **Gumroad** for maximum efficiency
- ⭐ **Accurate** and up-to-date data collection to ensure reliability
- ⭐ Supports bulk email scraping for large-scale data needs
- ⭐ User-friendly interface for easy operation and setup
- ⭐ **Customizable** scraping options to target specific data points
- ⭐ **Secure** and compliant data extraction to protect user privacy
- ⭐ **Fast** processing speeds to save time and resources
- ⭐ Export data in multiple formats for seamless integration
- ⭐ Real-time updates to ensure the latest data is captured
- ⭐ Compatible with various devices and operating systems
- ⭐ Detailed logs and reports for tracking scraping activities
- ⭐ 247 customer support for troubleshooting and assistance

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

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

1. ✅ Log in to the **Gumroad** Email Scraper platform with your account credentials
2. ✅ Enter the **Gumroad** URL or keywords related to the data you want to scrape
3. ✅ **Configure** the scraping settings such as data types and filters as needed
4. ✅ **Start** the scraping process and monitor its progress in real-time
5. ✅ Once completed review the extracted data in the provided dashboard
6. ✅ **Export** the data in your preferred format such as CSV or JSON
7. ✅ **Integrate** the exported data into your marketing or analysis tools
8. ✅ Repeat the process as needed for additional data extraction tasks

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Reach out to **Gumroad** sellers to showcase your products or services

Customer Engagement
🎯 Enhance communication with **Gumroad** customers through personalized emails
🎯 **Analyze** customer preferences to improve product offerings

Data Analysis
🎯 **Collect** structured email data for market research purposes
🎯 **Identify** trends and patterns in **Gumroad** transactions

Business Growth
🎯 Expand your network by connecting with **Gumroad** sellers and customers
🎯 Leverage email data to drive sales and increase revenue

### Why choose us? 💎

Our **Gumroad** Email Scraper is the **best** solution for extracting email data from **Gumroad** with accuracy and efficiency. It is equipped with **advanced** features that cater to the diverse needs of businesses and individuals.

Whether you are looking to generate email lists or analyze customer data, this tool provides **reliable** results every time. We prioritize user satisfaction by offering a **user-friendly** interface and customizable options.

Our scraper is designed to handle large-scale data extraction tasks without compromising on speed or quality. With 24/7 customer support and **regular** updates, we ensure that you have a seamless experience.

Choose our **Gumroad** email harvesting tool to save time, reduce manual effort, and achieve your business goals effectively. Trust us to deliver the **best** **Gumroad** email scraper software for your needs.

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

The **Gumroad** Email Scraper is built to handle data extraction tasks of any scale, making it suitable for both small businesses and large enterprises. Its robust infrastructure ensures that it can process large volumes of data without delays or errors.

Whether you need to extract a few emails or thousands, this tool delivers consistent performance. The scraper’s **customizable** settings allow you to tailor the extraction process to your specific needs.

It supports bulk scraping, enabling you to gather **extensive** data in a single session. With its scalable design, the tool grows with your business, adapting to increasing data demands over time.

Use the **Gumroad** email list generator to streamline your operations and achieve scalable results.

### **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** that all email scraping activities comply with **Gumroad**s terms of service
⚖️ **Obtain** consent from individuals before using their email data for marketing purposes
⚖️ **Do not** use the **Gumroad** Email Scraper for illegal or unethical activities
⚖️ Respect data privacy laws such as GDPR and CCPA when handling extracted data
⚖️ **Avoid** scraping sensitive or confidential information from **Gumroad**
⚖️ **Use** the tool responsibly to maintain the integrity of the **Gumroad** platform
⚖️ Regularly review legal regulations related to email scraping in your region
⚖️ **Ensure** that all extracted data is stored and processed securely

### 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 data from Gumroad for marketing, analysis, and communication purposes.

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

**Yes**, it is legal to use as long as you comply with Gumroad's terms of service and data privacy laws.

#### Can I **extract** emails in bulk using this tool?

**Yes**, the Gumroad Email Scraper supports bulk email extraction for large-scale data needs.

#### What formats can I **export** the **extract**ed data in?

You can export the data in formats like **CSV** or **JSON** for easy integration.

#### Does the scraper work on all devices?

**Yes**, the Gumroad Email Scraper is compatible with various devices and operating systems.

#### How accurate is the **extract**ed data?

The scraper ensures high accuracy by capturing up-to-date and reliable email data.

#### Can I customize the scraping process?

**Yes**, you can configure the settings to target specific data points and filters.

#### Is there **customer support** available?

**Yes**, we offer 24/7 customer support to assist with any issues or questions.

#### How fast is the scraping process?

The Gumroad Email Scraper is designed for fast processing speeds to save time.

#### Is my data **secure** while using the scraper?

**Yes**, we prioritize data security and ensure that all extracted data is handled safely.

#### Can I scrape data from **specific** Gumroad sellers?

**Yes**, you can target specific sellers by entering their profile URLs or related keywords.

#### Does the tool support real-time updates?

**Yes**, the scraper captures real-time data to ensure accuracy.

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

Please visit our website for detailed pricing information and subscription plans.

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

**Yes**, the scraper is ideal for collecting data for market research and analysis.

#### Is there a **limit** to the number of emails I can scrape?

**No**, the tool is scalable and can handle unlimited email extractions based on your needs.

# 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("scraper-engine/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("scraper-engine/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 scraper-engine/gumroad-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumroad Email Scraper",
        "description": "Gumroad Email Scraper extracts publicly available email addresses from Gumroad creator profiles and linked pages. Build targeted contact lists for partnerships, promotions, and direct creator outreach at scale.",
        "version": "0.1",
        "x-build-id": "6w2ybcHR9U2GocbXZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~gumroad-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~gumroad-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~gumroad-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```