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

Bandcamp Email Scraper extracts publicly available email addresses from Bandcamp artist and label profiles. Build targeted contact lists for promotions, partnerships, and direct artist outreach at scale.

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

### **Bandcamp** Email Scraper 📱
Bandcamp Email Scraper is a powerful bandcamp email scraper tool designed to scrape emails from Bandcamp artists and profiles. This bandcamp contact extractor tool supports automated Bandcamp scraping and bulk email extraction from Bandcamp, enabling scalable data collection for outreach and marketing. The bandcamp data scraper ensures accurate results while following platform guidelines. With advanced filtering, this bandcamp scraping automation tool helps users refine searches for better bandcamp lead generation scraping. It also functions as a reliable bandcamp scraping tool, offering multiple export formats for seamless integration into CRM systems and other marketing workflows.

### 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 |
| --- | --- |
| Artist Names | Extract public artist/band names using a bandcamp scraping tool for catalog analysis |
| Album & Track Data | Collect release titles and metadata via bandcamp data scraper |
| Genre Information | Identify genres for better segmentation in bandcamp scraping automation |
| Release Dates | Gather publishing timelines for trend analysis using automated Bandcamp scraping |
| Profile URLs | Extract public Bandcamp page links for structured datasets |
| Tags & Categories | Collect tags used on profiles for bandcamp scraping tool insights |
| Discography Data | Retrieve publicly listed discography details for music research |

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

Here are the standout features that make the Bandcamp Email Scraper a reliable tool for data extraction:

*   ⭐ Efficient bandcamp scraping tool for collecting public artist and release data
    
*   ⭐ User-friendly interface for smooth automated Bandcamp scraping
    
*   ⭐ Fully automated bandcamp data scraper for large-scale music data collection
    
*   ⭐ Built with compliance-focused bandcamp scraping automation practices
    
*   ⭐ Supports multiple export formats (CSV, JSON, Excel) for easy workflow integration
    
*   ⭐ Advanced filtering for genres, tags, and artists in bandcamp scraping automation tool
    
*   ⭐ Optimized for fast and scalable bulk bandcamp scraping automation

### How to use **Bandcamp** Email Scraper 🚀
Follow this simple step-by-step guide to extract Bandcamp data effortlessly — perfect for Apify users, automation workflows, and data analysis tools.

#### 🔧 Step-by-Step Guide

*   **Log in to Apify** — Create a free account or sign in.
*   **Select the Actor** — Search for **“Bandcamp Data Scraper”** in the Apify Store.
*   **Enter Input Data** —
*   Add Bandcamp artist pages, album URLs, or search queries.
*   **Choose Options** — Set filters like genre, tags, release type, or date range for **bandcamp scraping automation**.
*   **Run the Actor** — Click Start to begin **automated Bandcamp scraping** across selected pages.
*   **Download Results** — Export structured data in JSON, CSV, or Excel for analysis and integration.

💡 Pro Tip: Schedule recurring runs to automate **bandcamp data scraping** and keep music datasets always up to date.

### Use Cases 🎯
#### Music Data Analysis

Use a **bandcamp data scraper** to analyze artists, albums, genres, and release trends for research and insights

#### Market Research

Leverage **bandcamp scraping automation** to study music trends, niche genres, and audience preferences across the platform

#### Content Discovery

Discover emerging artists and trending releases using a **bandcamp scraping tool** for content curation and inspiration

#### Catalog & Dataset Building

Build structured music databases using **automated Bandcamp scraping** for analytics, recommendation systems, or media projects

### Why choose us? 💎
#### 🚀 Reliable Bandcamp Data Extraction

Our **bandcamp scraping tool** delivers accurate and efficient public music data collection for artists, albums, and release insights.

#### ⚙️ Automated & Scalable Performance

Powered by **automated Bandcamp scraping**, the tool supports scalable **bandcamp scraping automation** for large datasets and continuous workflows.

#### 🎯 Advanced Filtering & Precision

Use smart filters in the **bandcamp data scraper** to target genres, artists, tags, and release types with better accuracy.

#### 🔐 Ethical & Compliant Usage

Built with responsible **bandcamp scraping tool** practices to ensure compliance with platform guidelines and safe data usage.

#### 📊 Flexible Export & Integration

Export structured datasets in multiple formats for seamless integration into analytics platforms, dashboards, and research workflows.

### **Bandcamp** Email Scraper Scalability 📈
#### ⚡ Built for Flexible Data Extraction

The **bandcamp scraping tool** is designed to handle both small and large-scale **bandcamp data scraping** across artist pages, albums, and music catalogs.

#### 🚀 High-Volume Automated Scraping

With **automated Bandcamp scraping**, users can process large datasets efficiently through scalable **bandcamp scraping automation** workflows.

#### 🎯 Optimized for Accurate Results

The **bandcamp data scraper** supports advanced filters for genres, tags, artists, and releases to improve precision during extraction.

#### ⚙️ Reliable Performance at Scale

Powered by a robust **bandcamp scraping automation tool**, it ensures stable performance and consistent outputs for continuous data collection.

#### 📊 Designed for Research & Analytics

Whether for trend analysis or catalog building, this **bandcamp scraping tool** adapts easily to growing music data extraction needs.

### **Bandcamp** Email Scraper Legal Guidelines ⚖️
Using a bandcamp scraping tool is generally acceptable when focused on publicly available music and artist data while following ethical practices. This bandcamp data scraper supports responsible automated Bandcamp scraping for research, analytics, and market insights.

#### 📜 Legal & Ethical Guidelines

*    ⚖️ Follow Bandcamp’s Terms of Service when using any bandcamp scraping automation tool
    
*    ⚖️ Only collect publicly available data through automated Bandcamp scraping
    
*    ⚖️ Respect artist and user privacy when using a bandcamp data scraper
    
*    ⚖️ Avoid collecting or sharing sensitive personal information
    
*    ⚖️ Use extracted data responsibly for analytics, research, or discovery purposes
    
*    ⚖️ Comply with applicable data protection laws during bandcamp scraping automation
    
*    ⚖️ Regularly review platform policies to maintain safe and ethical bandcamp scraping tool practices

### 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 Data Scraper?

**Bandcamp Data Scraper** is a **bandcamp scraping tool** designed to collect publicly available artist, album, and music-related data for analytics and research.

#### Is Bandcamp Data Scraper legal to use?

Yes, when used responsibly. This **bandcamp scraping automation tool** is intended for public data collection while following Bandcamp’s terms and applicable laws.

#### What data can Bandcamp Data Scraper extract?

The **bandcamp data scraper** can collect artist names, album details, genres, tags, release dates, and other public music metadata.

#### How does Bandcamp Data Scraper work?

It uses **automated Bandcamp scraping** to gather structured public data based on selected filters, enabling scalable **bandcamp scraping automation** workflows for research and analysis.

### ✅ Conclusion

**Bandcamp Data Scraper** is a reliable **bandcamp scraping tool** designed for efficient and scalable extraction of publicly available music and artist data. With support for **automated Bandcamp scraping** and advanced filtering, it helps users collect structured insights from artist pages, albums, genres, and releases with accuracy. The **bandcamp data scraper** supports seamless exports for analytics, research, and content discovery workflows. Built with responsible **bandcamp scraping automation** practices, this solution is ideal for researchers, marketers, and music analysts looking to streamline large-scale music data collection efficiently and ethically.

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

```

## MCP server setup

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

```

## OpenAPI specification

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