# Redbubble Email Scraper (`scraper-engine/redbubble-email-scraper`) Actor

Redbubble Email Scraper extracts publicly available email addresses from Redbubble artist profiles and linked pages. Build targeted contact lists for artist outreach, partnerships, and marketplace collaboration at scale.

- **URL**: https://apify.com/scraper-engine/redbubble-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Developer tools, 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

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

Redbubble Email Scraper allows users to **extract** a wide range of **data** from Redbubble sellers. This includes essential **contact** details and seller-specific information to help you build a comprehensive **data**base.

The tool is designed to **extract** accurate and up-to-date information, ensuring that your **data** is reliable for outreach and marketing activities. With this scraper, you can gather **data** such as seller names, email addresses, shop details, and more.

The **extract**ed **data** can be used for various purposes, including marketing campaigns, research, and business collaborations. By automating the **data** collection process, the Redbubble Email Scraper saves time and effort while providing valuable insights into the seller community on Redbubble.

Redbubble Email Scraper is a powerful tool designed to help users extract valuable email contact information from Redbubble sellers efficiently. With this tool, you can gather data to connect with sellers for business or marketing purposes.

Social media platforms like Redbubble host a vast number of creative sellers, making it a prime source for discovering potential contacts. Redbubble Email Scraper simplifies the process of collecting email data from these sellers without manual effort.

Using advanced automation, this scraper ensures accuracy and compliance while saving you countless hours of manual work. It is an essential tool for marketers, researchers, and businesses looking to connect with Redbubble sellers.

### 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 |
| --- | --- |
| Seller Name | The full name of the Redbubble seller or shop owner. |
| Email Address | The email contact information of the seller for outreach purposes. |
| Shop Name | The name of the seller's shop on Redbubble. |
| Shop URL | The direct link to the seller's shop on Redbubble. |
| Product Categories | The categories of products offered by the seller in their shop. |
| Location | The geographical location of the seller if available. |
| Social Media Links | Links to the seller's social media profiles if shared on their Redbubble page. |
| Shop Description | A brief description of the seller's shop and offerings. |

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

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

- ⭐ Efficiently extracts email addresses and other seller details from Redbubble
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ Supports bulk data extraction for large-scale email scraping projects
- ⭐ Provides accurate and up-to-date contact information from sellers
- ⭐ **Customizable** scraping options to target specific data fields
- ⭐ Ensures compliance with legal and ethical guidelines for data scraping
- ⭐ Offers automated data collection to save time and resources
- ⭐ Delivers data in structured formats for easy integration into your workflow
- ⭐ Includes advanced filtering options to refine search results
- ⭐ Supports continuous updates to ensure compatibility with Redbubbles platform

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

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

1. ✅ **Sign up** for the Redbubble Email Scraper and **log in** to your account
2. ✅ Navigate to the tools dashboard and select the scraping options you need
3. ✅ Enter specific keywords categories or seller details to target your search
4. ✅ Set the data fields you want to extract such as email addresses and shop names
5. ✅ **Configure** any advanced settings such as filters or scraping limits
6. ✅ **Start** the scraping process and monitor progress on the dashboard
7. ✅ Once scraping is complete review the extracted data for accuracy
8. ✅ Download the data in your preferred format such as CSV or Excel
9. ✅ Use the data for your marketing research or outreach campaigns
10. ✅ Repeat the process as needed for additional data collection

### Use Cases 🎯

Marketing Campaigns
🎯 Build a Redbubble seller email list for targeted email marketing
🎯 Promote your products or services to Redbubble sellers via email

Business Collaboration
🎯 Connect with Redbubble sellers for potential partnerships
🎯 **Identify** sellers who align with your brand for collaboration opportunities

Market Research
🎯 **Analyze** seller data to understand trends and popular product categories
🎯 Gather insights into the Redbubble seller community for strategic planning

Lead Generation
🎯 Generate high-quality leads from Redbubble sellers for your business
🎯 Expand your contact database with verified email addresses from Redbubble

### Why choose us? 💎

Redbubble Email Scraper is the **best** Redbubble scraping software for extracting seller contact information efficiently and accurately. Our tool is designed with user-friendliness in mind, making it accessible to both beginners and professionals.

We prioritize compliance with legal and ethical standards, ensuring that your data scraping activities remain within the boundaries of the law. Our **advanced** automation technology saves you time and effort by streamlining the data collection process.

With customizable options, you can tailor the scraping process to meet your specific needs. Our tool is continuously updated to ensure compatibility with Redbubble's platform and deliver **reliable** results.

Whether you are looking to build a Redbubble email database or scrape Redbubble seller contacts, our tool provides the **best** solution. Choose Redbubble Email Scraper for its efficiency, accuracy, and commitment to delivering high-quality data.

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

Redbubble Email Scraper is built to handle projects of all sizes, from small-scale data collection to **large-scale** email scraping campaigns. Our tool supports bulk data extraction, allowing you to gather information from thousands of Redbubble sellers in a single session.

The scalable architecture ensures that performance remains consistent, even during **extensive** scraping tasks. Whether you are a small business or a large enterprise, our tool can adapt to your needs.

Customizable options allow you to focus on specific data fields or categories, making it suitable for diverse applications. With Redbubble Email Scraper, you can confidently scale your data collection efforts without compromising on quality or efficiency.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Redbubbles terms of service before using the scraper
⚖️ **Use** the tool only for ethical and legitimate purposes such as research or marketing
⚖️ **Do not** sell or distribute extracted data without the consent of the data owners
⚖️ **Avoid** scraping sensitive or private information not publicly available on Redbubble
⚖️ Respect the privacy of Redbubble sellers and do not misuse their contact information
⚖️ **Adhere** to data protection laws and regulations applicable in your region
⚖️ **Use** the tool responsibly to avoid overloading Redbubbles servers
⚖️ Regularly review updates to Redbubbles policies to ensure ongoing compliance

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

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

### FAQ ❓

#### What is Redbubble **Email Scraper**?

Redbubble Email Scraper is a tool designed to extract email addresses and other seller details from Redbubble efficiently.

#### Is it **legal** to scrape emails from Redbubble?

**Yes**, as long as you comply with Redbubble's terms of service and applicable data protection laws.

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

You can extract seller names, email addresses, shop names, shop URLs, product categories, and more.

#### Is the tool easy to use for **beginners**?

**Yes**, the tool features a **user-friendly** interface that requires no technical expertise.

#### Can I customize the data fields I want to scrape?

**Yes**, the tool allows you to select specific data fields for extraction.

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

You can download the data in formats like **CSV** or Excel directly from the dashboard.

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

**Yes**, the tool is regularly updated to ensure compatibility with Redbubble's platform.

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

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

#### What are the ethical guidelines for using this scraper?

Use the tool responsibly, respect seller privacy, and comply with legal and ethical standards.

#### Does the tool provide accurate and up-to-date data?

**Yes**, the tool is designed to extract accurate and current data from Redbubble.

#### Can I use this tool for **lead generation**?

**Yes**, the tool is ideal for generating high-quality leads from Redbubble sellers.

#### What happens if Redbubble changes its platform structure?

The tool is updated regularly to adapt to changes in Redbubble's platform structure.

#### Is there a **limit** to how much data I can scrape?

The tool supports scalable scraping, allowing you to extract as much data as needed.

#### Do I need technical skills to use this tool?

**No**, the tool is designed to be **user-friendly** and accessible to all users.

#### Can I target **specific** sellers or categories?

**Yes**, the tool allows you to customize your scraping process to target specific sellers or categories.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redbubble Email Scraper",
        "description": "Redbubble Email Scraper extracts publicly available email addresses from Redbubble artist profiles and linked pages. Build targeted contact lists for artist outreach, partnerships, and marketplace collaboration at scale.",
        "version": "0.1",
        "x-build-id": "Gw3OnUUM2ABsWrk3T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~redbubble-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-redbubble-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~redbubble-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-redbubble-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~redbubble-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-redbubble-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 Redbubble (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Redbubble profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Redbubble"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Redbubble"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```