# Bandcamp Audio Downloader (`scrapedrift/bandcamp-audio-downloader`) Actor

🎧 Bandcamp Audio Downloader lets you save your favorite Bandcamp tracks fast and hassle-free. Download audio with ease, organize your library, and enjoy offline listening anytime. 🚀✨

- **URL**: https://apify.com/scrapedrift/bandcamp-audio-downloader.md
- **Developed by:** [ScrapeDrift](https://apify.com/scrapedrift) (community)
- **Categories:** Automation, Other, Developer tools
- **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 Audio Downloader 🎵
Getting audio from Bandcamp tracks without downloading and organizing every link manually is surprisingly time-consuming. **Bandcamp Audio Downloader** extracts audio stream details and track metadata from your list of Bandcamp track URLs, so you can move from “find music” to “have usable audio data” fast. It’s ideal for downloading Bandcamp tracks in bulk, building a Bandcamp music downloader workflow, or preparing data for analysis. Marketers, analysts, and researchers use it to quickly compile structured results from Bandcamp audio sources. In one run, you can process multiple track URLs and get a clean dataset within seconds of starting.

### See the Data: Sample Output
Here's a real record from a single run:

```json
[
  {
    "url": "https://emilyhenry.bandcamp.com/track/oh-no",
    "result": {
      "url": "https://emilyhenry.bandcamp.com/track/oh-no",
      "title": "Oh No Emily Henry",
      "source": "bandcamp",
      "thumbnail": "https://example.com/thumbnail.jpg",
      "duration": 201,
      "medias": [
        {
          "url": "https://example.com/audio-stream.mp3",
          "quality": "HQ",
          "extension": "mp3",
          "type": "audio"
        }
      ],
      "type": "single",
      "error": false,
      "time_end": 1236
    }
  }
]
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The Bandcamp track URL that was processed in this record. |
| `result` | object | The structured extraction output for this specific track URL. |
| `result.url` | string | The canonical URL saved with the extraction result (same as input URL in normal cases). |
| `result.title` | string | A combined title built from track + artist when available, so you can quickly label items. |
| `result.source` | string | Indicates where the data comes from (saved as `bandcamp` for clarity). |
| `result.thumbnail` | string | Thumbnail URL when available, useful for previews in dashboards or feeds. |
| `result.duration` | number | Track duration value (or `0` if missing), helpful for sorting or filtering. |
| `result.medias` | array | The extracted media list (typically the best available audio stream). |
| `result.medias[].url` | string | Direct audio stream URL you can use downstream (for example, for Bandcamp MP3 downloader workflows). |
| `result.medias[].quality` | string | Quality label for the extracted media item (saved as `HQ`). |
| `result.medias[].extension` | string | File extension from the extraction (defaults to `mp3` when `ext` isn’t provided). |
| `result.medias[].type` | string | Media type (saved as `audio`). |
| `result.type` | string | Output type label (saved as `single`). |
| `result.error` | boolean | Whether extraction succeeded for this URL (`false` on success). |
| `result.message` | string | Present only on error: the error text describing what went wrong. |
| `result.time_end` | number | A fixed `time_end` value saved with the result record. |

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

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "urls": [
    "https://emilyhenry.bandcamp.com/track/oh-no"
  ]
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `urls` | ✅ | Provide a list of Bandcamp track URLs the actor will scrape for audio stream details and metadata. |

### What It Does

Bandcamp Audio Downloader extracts high-quality audio stream details and track metadata from Bandcamp track URLs you provide.

#### Extract bandcamp audio stream details for each track

For every URL in your `urls` input, the actor extracts the best available audio stream info and saves it into a structured media list. This makes Bandcamp Audio Downloader useful when you’re building a Bandcamp MP3 downloader workflow from prepared inputs.

#### Produce structured track metadata alongside the media

Each result includes a combined `title` (track + artist when available), a `thumbnail`, and a `duration` value. This helps you quickly review and label results for downstream use, including Bandcamp music downloader projects and dataset building.

#### Clean output that’s ready for processing

Results are pushed as JSON objects that include `url`, `result`, and a consistent structure for `medias` (including `quality`, `extension`, and `type`). This is convenient for analysts and data teams who want predictable fields for filtering and reporting, or for automation that needs a stable schema.

#### Handles errors without breaking the whole run

If extraction fails for a specific URL, the actor still returns a record with error information under `result`. You can keep going through a batch and review which track URLs failed, instead of losing everything.

#### Built-in proxy support for reliable scraping

The actor is configured to use built-in proxy support for more reliable extraction across multiple URLs. This is especially helpful for larger Bandcamp batch downloader runs.

Overall, Bandcamp Audio Downloader helps you turn a list of Bandcamp tracks into a structured dataset of audio stream details and metadata in one go.

### Why Bandcamp Audio Downloader?

There are plenty of ways to pull data from web pages—here’s why Bandcamp Audio Downloader stands out.

#### Purpose-built output for audio + metadata

Bandcamp Audio Downloader doesn’t just return a page link; it returns a structured result that includes audio media details and track metadata in a consistent format. That’s exactly what you need when your goal is “download Bandcamp tracks” at scale and keep results organized.

#### Batch-friendly for Bandcamp track downloader online workflows

You can feed multiple Bandcamp track URLs via the `urls` field and get back a dataset with one record per processed URL. This makes it a strong fit for Bandcamp album downloader and playlist-style workflows where you start from many track links.

#### Clear failure handling for real-world data

When something goes wrong for one track, the actor records an error payload for that URL so you can fix inputs and re-run selectively. This keeps your Bandcamp audio ripper pipeline more dependable when inputs vary in quality.

### Real-World Use Cases

Here’s how different teams put Bandcamp Audio Downloader to work:

**Sales & partnerships teams**\
A team building a catalog for outreach needs track-level metadata and media links from a long list of Bandcamp tracks. They run Bandcamp Audio Downloader on their prepared URL list, then load the dataset into their workflow to quickly review and prioritize artists based on duration and titles.

**Marketing agencies**\
An agency supporting multiple music clients needs consistent assets for reporting. They use Bandcamp Audio Downloader to generate a clean dataset of track titles, thumbnails, and extracted audio media details, so they can turn “batch music downloader” requests into ready-to-use exports without manual copy-paste.

**Freelance researchers & analysts**\
A researcher analyzing audio libraries wants a structured dataset to compute trends across tracks. They run Bandcamp Audio Downloader on the target URL list and ingest the resulting JSON into their analysis pipeline, filtering by duration and using `medias` entries as a traceable source for the audio items.

**Automation and data pipeline engineers**\
An engineer building an ingestion job wants stable output fields for downstream systems. They call Bandcamp Audio Downloader programmatically, then map `result.title`, `result.thumbnail`, `result.duration`, and `result.medias` into their database schema for ongoing enrichment and processing.

**Music curators & content ops**\
A curator collects tracks from multiple sources but needs them organized quickly for review. With Bandcamp Audio Downloader, they turn a batch of Bandcamp track links into a structured dataset they can review and export, speeding up their “download all tracks from Bandcamp” style workflows.

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify**\
   Go to the actor page in the Apify console: <https://console.apify.com>.

2. **Enter your inputs**\
   In the input pane, add your Bandcamp track URLs under the `urls` field (a list of strings).

3. **Configure proxy settings (optional)**\
   If you’re working with a larger set of URLs, enable proxy configuration for more reliable extraction.

4. **Start the run and watch the live log**\
   Click **Start** and monitor progress in the logs as each URL is processed.

5. **Open the Dataset tab to see live results**\
   As results are pushed, you’ll see records appear for each processed Bandcamp track URL.

6. **Export in your preferred format**\
   Download your dataset from the Apify dashboard as JSON, CSV, or Excel.

7. **Re-run only the failed URLs (if needed)**\
   If any records include an error payload, update your `urls` list and re-run to complete the batch.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

### Export & Integration Options

Once your data is collected, Bandcamp Audio Downloader fits directly into your existing workflow.

You can export your dataset from the Apify dashboard. The dataset tab supports downloads as JSON, CSV, or Excel, which makes it easy to use Bandcamp audio downloader output in spreadsheets, BI tools, or internal archives.

If you prefer automation, you can connect the run to your systems using Apify’s API access, webhooks, and no-code automation tools like Zapier or Make. For scheduled processing, you can also run the actor automatically on a recurring schedule using Apify’s scheduling options.

### Pricing

Bandcamp Audio Downloader runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier includes **$5 platform credits** on sign-up, which is enough for several real test runs. For heavier workloads, you can use Apify’s pay-as-you-go compute model and choose from subscription plans for more consistent throughput. Start free at [apify.com](https://apify.com) — scale up when you need to.

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate-limit resilience | Uses built-in pacing and robust extraction settings to keep runs stable. |
| Proxy support | Supports proxy configuration to improve reliability for batches. |
| Per-URL error handling | If a single URL fails, the actor records an error for that item instead of stopping the run. |
| Partial dataset output | Successfully processed URLs are pushed to the dataset as part of the run results. |
| Output consistency | Each record follows the same `url` + `result` structure, with `result.error` indicating success or failure. |

Limitations: Bandcamp Audio Downloader works on track URLs you supply, but extraction depends on the publicly available data accessible for those tracks. If a track fails to provide expected metadata or media details, the actor returns an error payload for that specific URL. For complex or very large workflows, you may need to adjust your input list and re-run failed entries to reach full coverage.

For enterprise-scale needs or custom configurations, reach out and we'll help.

### Frequently Asked Questions

#### Is there a free plan?

Yes—Apify offers a free tier so you can test Bandcamp Audio Downloader without committing to paid usage immediately.

#### Do I need to log in or create an account on Bandcamp?

No. This actor is designed to scrape publicly available sources based on the URLs you provide.

#### How accurate is the extracted data?

Accuracy depends on what’s available in the source track information. Bandcamp Audio Downloader extracts metadata fields like `title`, `thumbnail`, `duration`, and media stream details when available, and returns clear error information if extraction fails.

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

There’s no fixed number stated in the actor’s input schema. Practically, the number of results is based on how many track URLs you include in the `urls` array.

#### How fresh is the data?

The freshness corresponds to when you run the actor. Run time determines how current the extracted metadata and media details are at that moment.

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

Bandcamp Audio Downloader works with **publicly available data** tied to the Bandcamp track URLs you provide. You’re responsible for ensuring your use complies with applicable laws and any relevant platform terms, including GDPR and CCPA where applicable.

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

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, and then import it into Google Sheets or use it in Excel.

#### Can I schedule this to run automatically?

Yes. Apify supports scheduled runs, so you can run Bandcamp Audio Downloader automatically on a recurring basis.

#### Can I access results via the API?

Yes. You can access run results programmatically using Apify’s API.

#### What happens when the actor encounters an error?

If a specific URL fails during extraction, the actor still returns a record for that URL with `result.error: True` and includes `result.message` describing the issue. Successful URLs are returned as part of the same run results.

### Get Help & Use Responsibly

Got a question about Bandcamp Audio Downloader or a feature you'd like added? Reach out at <dataforleads@gmail.com> — we respond and actively maintain this actor based on user feedback. If you want improvements like support for batch-style album or playlist inputs (via track URLs) or enhancements to the exported structure, tell us what you’re building.

***

**This actor collects publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You are responsible for compliance with GDPR, CCPA, and any relevant platform terms. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `urls` (type: `array`):

List of Bandcamp track URLs to scrape.

## Actor input object example

```json
{
  "urls": [
    "https://emilyhenry.bandcamp.com/track/oh-no"
  ]
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapedrift/bandcamp-audio-downloader").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapedrift/bandcamp-audio-downloader").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 '{}' |
apify call scrapedrift/bandcamp-audio-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Audio Downloader",
        "description": "🎧 Bandcamp Audio Downloader lets you save your favorite Bandcamp tracks fast and hassle-free. Download audio with ease, organize your library, and enjoy offline listening anytime. 🚀✨",
        "version": "0.1",
        "x-build-id": "BHpdmVZCw0idbLBaF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapedrift~bandcamp-audio-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapedrift-bandcamp-audio-downloader",
                "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/scrapedrift~bandcamp-audio-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scrapedrift-bandcamp-audio-downloader",
                "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/scrapedrift~bandcamp-audio-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scrapedrift-bandcamp-audio-downloader",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Bandcamp Track URLs",
                        "type": "array",
                        "description": "List of Bandcamp track URLs to scrape.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://emilyhenry.bandcamp.com/track/oh-no"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
