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

📧 Gumroad Email Scraper extracts seller emails from Gumroad listings—fast, efficient, and export-ready. Perfect for lead generation, B2B outreach, and market research. 🎯 Save time, grow pipelines, and drive smarter sales.

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### **Gumroad** Email Scraper 📱

The **Gumroad** Email Scraper allows users to **extract** a variety of **data** points from **Gumroad** profiles. This includes email addresses, user names, and other publicly available information.

It is designed to help businesses and individuals gather **contact** **data** efficiently. The tool focuses on **extract**ing information that is visible on **Gumroad** profiles, ensuring compliance with **data** privacy regulations.

Users can also customize the scraping process to target specific types of **data**. By automating the **data** **extract**ion process, the **Gumroad** Email Scraper saves time and delivers accurate results.

It is a versatile tool suitable for marketers, researchers, and entrepreneurs looking to build targeted email lists from **Gumroad** users.

Gumroad Email Scraper is a powerful tool designed to help you extract email addresses from Gumroad user profiles efficiently and accurately. It simplifies the process of collecting contact data for marketing, networking, or research purposes.

With the Gumroad Email Scraper, you can automate the tedious task of manually gathering email addresses from Gumroad accounts. This tool is ideal for businesses and individuals looking to streamline their email extraction efforts.

Gumroad is a popular platform for creators and entrepreneurs, making it a valuable source of contact information. Our scraper ensures you can access this data quickly and compliantly.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract publicly available email addresses from Gumroad user profiles. |
| User Names | Retrieve the names of Gumroad users for personalized outreach. |
| Profile Links | Collect links to Gumroad user profiles for further analysis. |
| Product Information | Gather details about products listed by Gumroad users. |
| Social Media Links | Extract any social media links shared on Gumroad profiles. |
| Location Data | Retrieve location details if available on the user profiles. |
| Business Descriptions | Extract descriptions of businesses or services offered by users. |
| Custom Fields | Scrape additional custom fields visible on Gumroad profiles. |

### 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** profiles for efficiency
- ⭐ **Customizable** scraping options to target specific data types
- ⭐ **High** accuracy in extracting publicly available contact information
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Compliance with data privacy regulations and ethical guidelines
- ⭐ **Fast** processing to handle large-scale data extraction tasks
- ⭐ **Secure** data handling to protect user information during scraping
- ⭐ Detailed reporting and export options for extracted data
- ⭐ **Regular** updates to ensure compatibility with **Gumroad**s platform
- ⭐ 247 customer support to assist with any issues or questions

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

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

1. ✅ **Sign up** for an account on our platform to access the **Gumroad** Email Scraper
2. ✅ Log in to your account and navigate to the **Gumroad** Email Scraper tool
3. ✅ Enter the URL or profile details of the **Gumroad** accounts you want to scrape
4. ✅ Customize your scraping preferences such as data types and filters
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraping task in real-time on the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ Download the results in your preferred format such as CSV or Excel
9. ✅ Use the exported data for your marketing research or business needs
10. ✅ Repeat the process as needed for additional **Gumroad** profiles

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promoting your products or services
🎯 Reach out to **Gumroad** sellers with personalized marketing messages

Market Research
🎯 **Analyze** **Gumroad** user profiles to understand market trends
🎯 Gather data on competitors and their offerings

Networking Opportunities
🎯 Connect with creators and entrepreneurs on **Gumroad**
🎯 Expand your professional network by reaching out to potential collaborators

Business Development
🎯 **Identify** potential business partners on **Gumroad**
🎯 **Use** extracted data to explore new opportunities for growth

### Why choose us? 💎

Our **Gumroad** Email Scraper is designed to provide a seamless and efficient experience for extracting emails from **Gumroad** profiles. We prioritize accuracy and compliance, ensuring that all data is collected ethically and in accordance with privacy regulations.

Our tool is **user-friendly**, making it accessible to both technical and non-technical users. We offer customizable scraping options, allowing you to target specific data types based on your needs.

With fast processing and secure data handling, you can trust our scraper to deliver **reliable** results. Our team is dedicated to providing exceptional customer support, available 24/7 to assist with any questions or issues.

Regular updates ensure that our tool remains compatible with **Gumroad**'s platform, so you can continue to rely on it for your data extraction needs. Whether you're a marketer, researcher, or entrepreneur, our **Gumroad** Email Scraper is the **best** solution for building targeted email lists and gathering valuable contact data.

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

The **Gumroad** Email Scraper is built to handle data extraction tasks of all sizes, making it suitable for both small and **large-scale** projects. Whether you need to scrape a few profiles or thousands, our tool ensures fast and accurate results.

We use **advanced** algorithms to optimize the scraping process, reducing the time required to complete large tasks. Our platform supports batch processing, allowing you to input multiple profiles or URLs at once.

This scalability makes it ideal for businesses and researchers with **extensive** data collection needs. Additionally, our tool is hosted on robust servers to ensure consistent performance even during high-demand periods.

With the ability to scale up or down based on your requirements, the **Gumroad** Email Scraper is a versatile solution for all your email extraction needs.

### **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** you have permission to scrape data from **Gumroad** profiles
⚖️ **Only** extract publicly available information visible on user profiles
⚖️ **Do not** use the scraper for illegal or unethical purposes
⚖️ Comply with all applicable data privacy laws and regulations
⚖️ **Avoid** scraping sensitive or private information without consent
⚖️ **Use** the extracted data responsibly and for legitimate purposes
⚖️ Respect **Gumroad**s terms of service and platform guidelines
⚖️ Consult with legal professionals if you are unsure about compliance

### 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 Gumroad user profiles.

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

**Yes**, it is legal to use as long as you comply with data privacy laws and only extract **publicly available** information.

#### What types of data can I **extract**?

You can extract email addresses, user names, profile links, product information, and more.

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

Our scraper is designed to deliver high accuracy by focusing on publicly visible information.

#### Can I customize the data **extract**ion process?

**Yes**, you can customize the scraping preferences to target specific data types.

#### Is the tool compatible with all Gumroad profiles?

The tool works with publicly accessible Gumroad profiles and complies with platform guidelines.

#### How do I download the **extract**ed data?

You can download the results in formats like **CSV** or Excel after the scraping task is complete.

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

**Yes**, our team provides 24/7 customer support to assist with any issues or questions.

#### Can the scraper handle **large-scale** projects?

**Yes**, the Gumroad Email Scraper is scalable and can handle tasks of all sizes efficiently.

#### Are there any **limit**ations on the data I can scrape?

You can only scrape **publicly available** information and must comply with legal and ethical guidelines.

#### How often is the tool updated?

We regularly update the tool to ensure compatibility with Gumroad's platform and maintain optimal performance.

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

**Yes**, we use **secure** data handling practices to protect user information during the scraping process.

#### Can I use the scraper for marketing purposes?

**Yes**, the tool is ideal for building targeted email lists for marketing campaigns.

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

The Gumroad Email Scraper is a web-based tool, so you only need an internet connection and a compatible browser.

#### Can I scrape data from **private** Gumroad profiles?

**No**, the tool only extracts data from publicly accessible profiles in **compliance** with privacy laws.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilotapi/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 seller emails from Gumroad listings—fast, efficient, and export-ready. Perfect for lead generation, B2B outreach, and market research. 🎯 Save time, grow pipelines, and drive smarter sales.",
        "version": "0.1",
        "x-build-id": "c7qjtMjhiCUj3httR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~gumroad-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-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/scrapepilotapi~gumroad-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-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/scrapepilotapi~gumroad-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```