# Bandcamp Email Scraper Fast Advanced And Cheapest (`scraperoka/bandcamp-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Bandcamp Email Scraper Fast Advanced & Cheapest extracts verified emails from Bandcamp pages with speed and advanced filtering. Perfect for targeted outreach, marketing, and lead generation. 💼⚡ Affordable.

- **URL**: https://apify.com/scraperoka/bandcamp-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 - Fast, Advanced and Cheapest 🎯

Manually hunting for Bandcamp contact emails across many profiles wastes hours you don’t have. **Bandcamp Email Scraper - Fast, Advanced and Cheapest** extracts emails from Bandcamp based on your keywords and email-domain filters, so you can build outreach lists fast. This Bandcamp email scraper (including “get bandcamp emails” and “bandcamp lead generation tool” use cases) is ideal for marketers, recruiters, and growth teams who need thousands of records in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Bandcamp.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "https://example.com/bandcamp-sample-page",
  "email": "hello@gmail.com"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network used for the lead (always `Bandcamp.com`) |
| `keyword` | string | Which keyword/query produced this specific lead |
| `title` | string | The result title tied to the lead (or a fallback like `No title`) |
| `description` | string | The surrounding text the actor used to detect the email (or a fallback) |
| `url` | string | The page URL where the lead information was found |
| `email` | string | The extracted email address you can use for outreach |
| `charged_event_name` | string | The actor pushes each row with `charged_event_name="result"` during dataset writes |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Bandcamp Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull contact data from Bandcamp — here’s what sets **Bandcamp Email Scraper - Fast, Advanced and Cheapest** apart.

#### Keyword-Driven Bandcamp Email Harvesting

You control what gets targeted by supplying `keywords` (like roles such as manager or founder) and optional `location`. This makes it easier to use a bandcamp email harvesting tool approach that matches your outreach intent.

#### Domain Filters for Cleaner Leads

Use `customDomains` (for example `@gmail.com` or `@yahoo.com`) so results focus on the email providers that matter for your campaign. If you’re searching for a bandcamp contact email extractor, this helps reduce noise.

#### Resumable Progress for Long Runs

The actor saves progress so you can resume without starting over. That means fewer wasted cycles if you hit time limits or need to re-run with updated inputs.

#### Controlled Result Limits for Cost Management

You can set `maxEmails` to stop once you reach your desired volume. This is useful when you’re looking for a fastest and cheapest bandcamp email scraper strategy that keeps scraping time—and cost—in check.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Provide a list of keywords or queries to search for when extracting Bandcamp emails |
| `location` | ⬜ | Filters results by a location string (leave empty for no location filter) |
| `customDomains` | ⬜ | Restricts extracted emails to the email domains you specify (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Sets a cap on the number of emails to collect before the scraper stops (helps control runtime and costs) |

***

### Core Capabilities

#### Email Extraction From Bandcamp

This actor extracts email addresses from Bandcamp using the `keywords` and `customDomains` you provide. If you’re after a bandcamp email list or a bandcamp email database, the dataset is built to be outreach-ready.

#### Flexible Input for Targeted Searches

You can combine multiple `keywords` with multiple `customDomains`, and optionally add a `location` filter. This makes the “bandcamp scraper email” workflow more controllable and repeatable.

#### Deduplicated Results Within a Run

The scraper keeps track of `seen_emails`, so the dataset focuses on unique email addresses rather than repeatedly outputting the same contact.

#### Resilience With Built-In Stop/Continue Logic

The actor includes logic to stop early when it detects no new results across consecutive pages, helping runs complete without unnecessary overhead. It also saves progress so you can continue later.

#### Clean, Structured Output to the Dataset

Each lead is pushed as a row with consistent fields: `network`, `keyword`, `title`, `description`, `url`, and `email`. That structure is ideal for turning scraped data into a contact list quickly.

Overall, this is a fast, advanced, and cost-conscious way to get bandcamp emails for lead generation.

***

### Who Gets the Most Out of This

Here's how different teams put Bandcamp Email Scraper - Fast, Advanced and Cheapest to work:

**Marketing Managers**\
Use keywords like manager and founder alongside targeted `customDomains` to build a Bandcamp contact email extractor list for specific outreach campaigns. You can cap volume with `maxEmails` to run controlled experiments before scaling.

**Recruiters & Staffing Teams**\
When you need to contact role-relevant creators, bands, or labels, your `keywords` help steer what you’re harvesting. The output includes the source `url` and extracted `email`, so it’s easier to validate leads during outreach.

**Freelance Researchers & Data Analysts**\
You can run repeatable keyword-and-domain harvesting to compile a bandcamp email database for analysis or reporting. The dataset structure (keyword, title, description, url, email) supports downstream enrichment and filtering.

**Automation & Integration Developers**\
Build workflows that pull dataset results from Apify and push them into your pipeline. The consistent output schema makes it straightforward to map into CRMs or contact systems for a bulk bandcamp email scraper workflow.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Bandcamp Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find the actor.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use your preferred proxy configuration in Apify for reliable scraping runs.
4. **Hit Run and watch the live log** — track progress as the actor extracts and pushes results.
5. **View results in the dataset tab** — each lead is added to the dataset as it’s found.
6. **Export as JSON, CSV, or Excel** — download the dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Bandcamp Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export your Apify dataset as **JSON, CSV, or Excel** directly from the Apify dashboard. This makes it easy to turn a bandcamp email harvesting tool run into a usable bandcamp email list for analysis or outreach.

For automation, use Apify’s **API access**, plus no-code options like **Zapier / Make** and **webhooks** to push results into your CRM, spreadsheets, or downstream systems. For more details on connecting and scheduling, refer to Apify documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Bandcamp Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically start with a small amount of platform credits for testing, then scale as needed using Apify’s pay-as-you-go model based on compute usage.

To see the exact current plan limits and credit structure, check Apify pricing directly. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Partial run recovery | The actor persists progress so you can resume |
| Result control | `maxEmails` stops when you reach your requested cap |
| Cleaner results | Emails are tracked to avoid duplicates within the run |
| Runtime efficiency | Stops when consecutive pages yield no new emails |

**Limitations:** This actor focuses on emails found in publicly available Bandcamp-related sources. It can only extract emails that are actually present in the content it processes, so some keyword/domain combinations may yield fewer results.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier for trying actors. If you’re testing a bandcamp email scraper workflow, start with a small `maxEmails` value and targeted `customDomains`.

#### Do I need to log in to Bandcamp to use this?

No. This actor is designed to work with publicly available information, so you can run it without Bandcamp login credentials.

#### How accurate is the data?

Accuracy depends on what email addresses are publicly displayed in the sources the actor processes. The scraper extracts emails it detects that match your `customDomains` filters and returns them as `email`.

#### How many results can I get per run?

You control the maximum with `maxEmails`. Note that on free usage, a result cap may be applied by the actor logic.

#### How often is the data updated / how fresh is it?

Freshness is tied to when you run the actor. Each run scrapes and writes results incrementally to the dataset, so your newest dataset reflects the time of execution.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data**. It’s your responsibility to ensure you comply with GDPR, CCPA, applicable laws, and the platform’s terms when using or storing the extracted emails.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard. For Google Sheets specifically, you can also use automations via Apify integrations like Zapier / Make (see Apify docs for details).

#### Can I run this on a schedule automatically?

Yes. You can schedule runs on the Apify platform. This is useful if you want to keep a bandcamp artist email finder list updated over time.

#### Can I access this via API?

Yes. You can pull results programmatically using the Apify API. See [apify.com/docs/api](https://apify.com/docs/api) for integration details.

#### What happens if the actor hits an error?

The actor writes results incrementally to the dataset as it finds them, and it also saves progress so you can resume. If there are periods with limited or no new emails, the actor stops based on its built-in page stop logic.

***

### Need Help or Have a Request?

Got a question about Bandcamp Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Email us at <dataforleads@gmail.com>. We welcome requests like batch CSV upload improvements and webhook notifications on completion. We also actively maintain this actor based on user feedback.

***

### Disclaimer & Responsible Use

*Bandcamp Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to find Bandcamp contact emails — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/bandcamp-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/bandcamp-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/bandcamp-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Bandcamp Email Scraper Fast Advanced & Cheapest extracts verified emails from Bandcamp pages with speed and advanced filtering. Perfect for targeted outreach, marketing, and lead generation. 💼⚡ Affordable.",
        "version": "1.0",
        "x-build-id": "MrrpnAwpJ2KJvKjSG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~bandcamp-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-bandcamp-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~bandcamp-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-bandcamp-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~bandcamp-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-bandcamp-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
