# Bandcamp Email Scraper (`scrapepilotapi/bandcamp-email-scraper`) Actor

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

### **Bandcamp** Email Scraper 📱

**Bandcamp** Email Scraper enables the **extract**ion of publicly available **contact** information from **Bandcamp** profiles. It is designed to collect **data** such as artist **emails**, profile names, and social media links.

This tool ensures that you can gather essential information for networking or marketing purposes. By automating the **data** collection process, it saves time and effort while maintaining accuracy.

The **extract**ed **data** can be exported into organized formats for easy use. This makes it ideal for creating email lists, conducting outreach campaigns, or building a **contact** **data**base.

With its ability to **extract** multiple **data** types, **Bandcamp** Email Scraper is a versatile solution for professionals in the music industry.

Bandcamp Email Scraper is a powerful tool designed to help you collect email addresses from Bandcamp profiles efficiently. It is ideal for music professionals, marketers, and researchers looking to connect with artists and labels on Bandcamp.

With Bandcamp Email Scraper, you can automate the process of gathering contact information from Bandcamp, saving time and effort. This tool is perfect for building email lists for promotional campaigns or networking opportunities.

Our Bandcamp email extractor is designed to ensure accuracy and reliability while adhering to ethical data collection practices. It provides a seamless way to access publicly available contact details from Bandcamp profiles.

### 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 Bandcamp artist profiles. |
| Artist names | Retrieve the names of artists or bands from their Bandcamp profiles. |
| Profile URLs | Collect direct links to Bandcamp profiles for easy access. |
| Social media links | Extract links to artists’ social media accounts listed on their Bandcamp profiles. |
| Genres | Identify the genres associated with artists or bands on Bandcamp. |
| Location | Gather location details of artists or bands if available on their profiles. |
| Albums or tracks | Retrieve information about albums or tracks listed on Bandcamp profiles. |
| Contact forms | Identify and extract links to contact forms provided on Bandcamp profiles. |

### Key Features of **Bandcamp** Email Scraper

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

- ⭐ Automates the process of extracting email addresses from **Bandcamp** profiles
- ⭐ Supports the collection of multiple data types including artist names and social media links
- ⭐ Offers high accuracy and reliability in data extraction results
- ⭐ Exports extracted data in organized formats such as CSV or Excel for easy use
- ⭐ Adheres to ethical data collection practices and respects platform guidelines
- ⭐ Provides a user-friendly interface for seamless operation
- ⭐ Allows batch processing for scraping multiple profiles simultaneously
- ⭐ Includes customizable filters to target specific genres locations or other parameters
- ⭐ **Regular**ly updated to ensure compatibility with **Bandcamp**s platform changes
- ⭐ Offers robust customer support for troubleshooting and assistance

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

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

1. ✅ **Sign up** for the **Bandcamp** Email Scraper tool on our platform
2. ✅ Log in to your account and navigate to the scraper dashboard
3. ✅ Enter the **Bandcamp** profile URLs or keywords you want to scrape data from
4. ✅ **Select** the data types you wish to extract such as email addresses or artist names
5. ✅ Apply any filters such as genre or location to refine your search results
6. ✅ **Start** the scraping process and monitor the progress on the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ **Export** the data to your preferred format such as CSV or Excel for further use
9. ✅ Use the exported data for email campaigns networking or research purposes
10. ✅ Repeat the process as needed for additional **Bandcamp** profiles or keywords

### Use Cases 🎯

Music Promotion
🎯 Build email lists of artists for promotional campaigns
🎯 Connect with bands and labels for collaboration opportunities

Artist Management
🎯 **Identify** potential clients or artists to represent
🎯 Gather contact details for outreach and networking

Market Research
🎯 **Analyze** trends in genres and artist locations
🎯 **Collect** data for understanding the **Bandcamp** music ecosystem

Event Planning
🎯 **Find** artists to book for music festivals or events
🎯 Reach out to bands for live performances or partnerships

### Why choose us? 💎

Our **Bandcamp** Email Scraper is designed with the needs of music professionals in mind. It offers a **reliable** and efficient way to collect email addresses and other data from **Bandcamp** profiles.

By automating the data collection process, our tool saves you time and effort, allowing you to focus on building meaningful connections. We prioritize accuracy and ensure that the extracted data is organized and ready for use.

Our scraper is **regular**ly updated to remain compatible with **Bandcamp**'s platform changes, ensuring uninterrupted service. With a **user-friendly** interface and customizable filters, it is accessible to both beginners and experienced users.

We also provide robust customer support to assist you with any questions or issues. Choose our **Bandcamp** Email Scraper for a hassle-free and effective data extraction experience.

### **Bandcamp** Email Scraper Scalability 📈

**Bandcamp** Email Scraper is built to handle data extraction tasks of any scale. Whether you need to scrape a few profiles or thousands, our tool is equipped to manage the workload **efficient**ly.

It supports batch processing, allowing you to extract data from multiple profiles simultaneously. This makes it a suitable solution for both small-scale users and large organizations.

The tool is optimized for speed and accuracy, ensuring that you can collect data quickly without compromising quality. As your data extraction needs grow, our scraper can scale with you, providing the same level of performance and reliability.

With its robust infrastructure, **Bandcamp** Email Scraper is a scalable solution for professionals in the music industry.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Bandcamp**s terms of service when using the scraper
⚖️ **Only** collect publicly available data from **Bandcamp** profiles
⚖️ **Do not** use the scraper for spamming or unethical marketing practices
⚖️ Respect the privacy of individuals and avoid scraping sensitive information
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ **Adhere** to local data protection laws and regulations when using the scraper
⚖️ **Avoid** overloading **Bandcamp**s servers by using the tool responsibly
⚖️ Regularly review **Bandcamp**s policies to ensure continued compliance

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Bandcamp **Email Scraper**?

Bandcamp Email Scraper is a tool designed to extract email addresses and other data from Bandcamp profiles.

#### Is it **legal** to use Bandcamp **Email Scraper**?

**Yes**, as long as you comply with Bandcamp's terms of service and only collect **publicly available** data.

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

You can extract email addresses, artist names, profile URLs, social media links, genres, and more.

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

The tool allows you to export data in formats like **CSV** or Excel for easy use.

#### Can I scrape multiple profiles at once?

**Yes**, the scraper supports batch processing for extracting data from multiple profiles simultaneously.

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

The scraper works with publicly accessible Bandcamp profiles that contain the desired data.

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

**No**, the tool features a **user-friendly** interface suitable for users of all experience levels.

#### How often is the scraper updated?

The scraper is regularly updated to ensure compatibility with Bandcamp's platform changes.

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

**Yes**, you can apply filters such as genre or location to refine your search results.

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

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

#### Does the scraper respect data privacy laws?

**Yes**, the tool is designed to comply with local data protection laws and ethical guidelines.

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

Pricing details are available on our platform, and we offer flexible plans to suit different needs.

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

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

#### What happens if Bandcamp updates its platform?

Our scraper is regularly updated to remain compatible with Bandcamp's platform changes.

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

The tool is scalable and can handle data extraction tasks of any size.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Email Scraper",
        "version": "0.1",
        "x-build-id": "L4M4y9GIZewS5rbdg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~bandcamp-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-bandcamp-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~bandcamp-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-bandcamp-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~bandcamp-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-bandcamp-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 Bandcamp (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Bandcamp profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Bandcamp"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Bandcamp"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```