# SoundCloud MP3 Downloader (`maximedupre/soundcloud-mp3-downloader`) Actor

Get playable SoundCloud media links from track URLs, profiles, playlists, and search terms. Export progressive MP3 URLs, HLS links, track metadata, artist details, engagement counts, and timestamps.

- **URL**: https://apify.com/maximedupre/soundcloud-mp3-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.65 / 1,000 soundcloud tracks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### 🎧 Get SoundCloud MP3 links from public tracks

SoundCloud MP3 Downloader finds playable media links from public [SoundCloud](https://soundcloud.com/) tracks, profiles, playlists, and search terms. Add a track URL, an artist handle, a playlist URL, or a keyword such as `ambient`, then export resolved progressive MP3 URLs, HLS stream links, track metadata, artist details, engagement counts, and source URLs to an Apify dataset.

Use this SoundCloud MP3 downloader when you need a clean list of public track media links for music research, catalog review, content workflows, audio analysis, or an API pipeline. The Actor does not require a SoundCloud login, cookies, or your own API key. It saves one row per public playable track with a usable `media.preferredUrl`.

For a small first run, keep the prefilled `ambient` search. The default run saves up to 25 tracks, which is enough to check the output shape before you add more SoundCloud targets.

### ✅ What this SoundCloud MP3 downloader does

- Accepts SoundCloud track URLs, artist/profile URLs, `@handles`, playlist URLs, and plain search terms.
- Resolves public playable tracks into media links.
- Prefers progressive MP3 URLs when SoundCloud exposes them.
- Also returns HLS MP3 links and other available stream variants.
- Saves track title, URL, duration, artwork, genre, tags, license, release dates, and scrape time.
- Adds artist profile details such as username, profile URL, avatar, follower count, track count, verified flag, and Pro flag when SoundCloud exposes them.
- Adds engagement counts such as plays, likes, reposts, comments, and downloads when available.
- Skips private, deleted, unavailable, non-playable, duplicate, or media-less tracks instead of charging for failure rows.

### 📊 Data you can get

Each saved row is a public SoundCloud track with at least one resolved media URL. Core fields include:

- `input`, `inputType`, and `sourceUrl`
- `trackId`, `trackUrn`, `trackUrl`, and `title`
- `artistName`, `artistUrl`, and the nested `artist` object
- `durationMs` and `durationText`
- `artworkUrl`, `waveformUrl`, `genre`, `tags`, `license`, `createdAt`, and `releaseDate`
- `downloadable` and `streamable`
- `media.preferredUrl`
- `media.progressiveMp3Url` when available
- `media.hlsMp3Url` when available
- `media.variants` with protocol, MIME type, preset, quality, extension, and selected preferred variant
- `engagement` counts
- `searchContext` for rows found from search terms
- `scrapedAt`

Some fields can be `null` when SoundCloud does not show that value for a public track.

### 🚀 Common use cases

- Collect SoundCloud download links for public playable tracks.
- Build a music research dataset with titles, artists, genres, tags, and engagement counts.
- Review tracks from a SoundCloud playlist or artist profile.
- Find progressive MP3 links for tracks returned by a keyword search.
- Feed public track metadata and stream URLs into an audio analysis, AI, BI, or catalog workflow.
- Schedule recurring SoundCloud searches and export fresh datasets through the Apify API, webhooks, or integrations.

### ▶️ How to run it

1. Add one or more entries in **SoundCloud targets**.
2. Use track URLs for exact tracks, playlist URLs for playlist tracks, `@handles` for artist profiles, or search terms for track discovery.
3. Set **Total track limit** and **Tracks per target** to control run size and cost.
4. Choose **Sort** if your target type supports ordering.
5. Turn on **Only marked downloadable** if you only want tracks SoundCloud marks as downloadable.
6. Start the Actor and open the dataset.

For quick tests, use one target and a low track limit. For larger runs, add several targets and raise the limits gradually.

### 🛠️ Input

#### 🧪 Example input

```json
{
	"targets": [
		"ambient",
		"https://soundcloud.com/example/sets/example-playlist",
		"@exampleartist"
	],
	"maxTotalTracks": 25,
	"maxTracksPerTarget": 25,
	"sort": "sourceDefault",
	"onlyDownloadable": false,
	"continueOnUnavailable": true,
	"dedupeTracks": true
}
````

#### 🎛️ Input fields

| Field | What to enter |
| ----- | ------------- |
| `targets` | SoundCloud track URLs, profile URLs, `@handles`, playlist URLs, or search terms. |
| `maxTotalTracks` | Maximum tracks to save across the whole run. |
| `maxTracksPerTarget` | Maximum tracks to save from each target before moving to the next one. |
| `sort` | `sourceDefault`, `newest`, or `popular` where SoundCloud supports ordering. |
| `onlyDownloadable` | Save only tracks SoundCloud marks as downloadable. |
| `continueOnUnavailable` | Continue with the next target if one target has no public playable tracks. |
| `dedupeTracks` | Skip the same SoundCloud track if it appears more than once in a run. |

### 📦 Output example

```json
{
	"status": "available",
	"input": "ambient",
	"inputType": "search",
	"sourceUrl": "https://api-v2.soundcloud.com/search/tracks?q=ambient",
	"trackId": 123456789,
	"trackUrn": "soundcloud:tracks:123456789",
	"trackUrl": "https://soundcloud.com/artist/example-track",
	"title": "Example track",
	"artistName": "Example Artist",
	"artistUrl": "https://soundcloud.com/artist",
	"durationMs": 180000,
	"durationText": "3:00",
	"artworkUrl": "https://i1.sndcdn.com/artworks-example-large.jpg",
	"downloadable": false,
	"streamable": true,
	"media": {
		"preferredUrl": "https://cf-media.sndcdn.com/example.128.mp3",
		"preferredFormat": "progressive audio/mpeg",
		"progressiveMp3Url": "https://cf-media.sndcdn.com/example.128.mp3",
		"hlsMp3Url": "https://cf-hls-media.sndcdn.com/playlist/example.128.mp3/playlist.m3u8",
		"variants": [
			{
				"url": "https://cf-media.sndcdn.com/example.128.mp3",
				"protocol": "progressive",
				"mimeType": "audio/mpeg",
				"preset": "mp3_1_0",
				"quality": "sq",
				"durationMs": 180000,
				"extension": "mp3",
				"isPreferred": true
			}
		]
	},
	"engagement": {
		"playbackCount": 10000,
		"likesCount": 500,
		"repostsCount": 20,
		"commentCount": 12,
		"downloadCount": null
	},
	"scrapedAt": "2026-05-28T00:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You pay only for each public SoundCloud track saved with a resolved media URL. Failed, unavailable, duplicate, private, deleted, non-playable, and media-less targets are skipped and are not saved as charged dataset rows.

The configured event price is `$0.00265` per saved track, or `$2.65 per 1,000 saved tracks`.

### ⚠️ Limits and caveats

This Actor works with public SoundCloud content only. It cannot access private tracks, deleted tracks, login-only pages, or tracks SoundCloud does not expose as playable public media.

The Actor returns media URLs that SoundCloud provides for public playback. These URLs can be signed and time-limited, so rerun the Actor when you need fresh links. It does not store audio files in Apify key-value storage; it returns source media URLs and metadata in the dataset.

The **Only marked downloadable** filter uses SoundCloud's public `downloadable` flag. Leave it off if you want all public playable tracks with resolved media links.

### ❓ FAQ

#### 🔊 Does this download the audio file into Apify storage?

No. It resolves and saves SoundCloud media URLs in the dataset. Use the returned `media.preferredUrl` or `media.progressiveMp3Url` in your own workflow if you need to fetch the file.

#### 👤 Can I use profile or playlist URLs?

Yes. The Actor can expand public artist profiles and playlists into track rows, then resolve media links for each playable track up to your selected limits.

#### ⬇️ Why is `downloadable` false when an MP3 link exists?

SoundCloud's `downloadable` flag and public playback media are different. A track can be playable and expose a streaming MP3 URL even when SoundCloud does not mark it as officially downloadable.

#### 🧹 Are failed targets saved?

No. The Actor saves only successful public track rows with a resolved media URL. Unavailable targets are shown in logs and skipped.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~soundcloud-mp3-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [SoundCloud Scraper ↗](https://apify.com/maximedupre/soundcloud-scraper) - Scrape public SoundCloud tracks, artists, playlists, albums, comments, engagement counts, and media metadata.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download public TikTok video and audio files with captions, author data, and file metadata.
- [Instagram Downloader API ↗](https://apify.com/maximedupre/instagram-downloader-api) - Extract media URLs, thumbnails, captions, and engagement counts from public Instagram posts and reels.
- [Telegram Media Downloader ↗](https://apify.com/maximedupre/telegram-media-downloader) - Get media URLs and post data from public Telegram posts, channels, groups, and `@handles`.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public YouTube channel profiles, recent videos, views, thumbnails, and source URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter SoundCloud track URLs, profile URLs, @handles like @artist, playlist URLs, or search terms like ambient techno. Each target is processed separately.

## `maxTotalTracks` (type: `integer`):

Maximum public playable SoundCloud tracks to save across the whole run.

## `maxTracksPerTarget` (type: `integer`):

Maximum playable tracks to save from each target before moving to the next one.

## `sort` (type: `string`):

Choose how to ask SoundCloud for tracks when the target supports ordering. Direct track URLs always return that exact track.

## `onlyDownloadable` (type: `boolean`):

Save only tracks SoundCloud marks as downloadable. Leave this off to save any public playable track with a resolved media URL.

## `continueOnUnavailable` (type: `boolean`):

Continue with the remaining targets when one target has no public playable tracks or media links.

## `dedupeTracks` (type: `boolean`):

Avoid saving the same SoundCloud track more than once in the same run.

## Actor input object example

```json
{
  "targets": [
    "ambient"
  ],
  "maxTotalTracks": 25,
  "maxTracksPerTarget": 25,
  "sort": "sourceDefault",
  "onlyDownloadable": false,
  "continueOnUnavailable": true,
  "dedupeTracks": true
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with SoundCloud track metadata, artist details, progressive MP3 URLs, HLS stream links, engagement counts, and scrape timestamps.

# 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 = {
    "targets": [
        "ambient"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/soundcloud-mp3-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 = { "targets": ["ambient"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/soundcloud-mp3-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 '{
  "targets": [
    "ambient"
  ]
}' |
apify call maximedupre/soundcloud-mp3-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud MP3 Downloader",
        "description": "Get playable SoundCloud media links from track URLs, profiles, playlists, and search terms. Export progressive MP3 URLs, HLS links, track metadata, artist details, engagement counts, and timestamps.",
        "version": "0.1",
        "x-build-id": "UBR6fmAJpdr0S0b7f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~soundcloud-mp3-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-soundcloud-mp3-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/maximedupre~soundcloud-mp3-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-soundcloud-mp3-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/maximedupre~soundcloud-mp3-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-soundcloud-mp3-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "SoundCloud targets",
                        "type": "array",
                        "description": "Enter SoundCloud track URLs, profile URLs, @handles like @artist, playlist URLs, or search terms like ambient techno. Each target is processed separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxTotalTracks": {
                        "title": "Total tracks",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum public playable SoundCloud tracks to save across the whole run.",
                        "default": 25
                    },
                    "maxTracksPerTarget": {
                        "title": "Tracks per target",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum playable tracks to save from each target before moving to the next one.",
                        "default": 25
                    },
                    "sort": {
                        "title": "Track order",
                        "enum": [
                            "sourceDefault",
                            "newest",
                            "popular"
                        ],
                        "type": "string",
                        "description": "Choose how to ask SoundCloud for tracks when the target supports ordering. Direct track URLs always return that exact track.",
                        "default": "sourceDefault"
                    },
                    "onlyDownloadable": {
                        "title": "Only downloadable",
                        "type": "boolean",
                        "description": "Save only tracks SoundCloud marks as downloadable. Leave this off to save any public playable track with a resolved media URL.",
                        "default": false
                    },
                    "continueOnUnavailable": {
                        "title": "Continue on empty targets",
                        "type": "boolean",
                        "description": "Continue with the remaining targets when one target has no public playable tracks or media links.",
                        "default": true
                    },
                    "dedupeTracks": {
                        "title": "Skip duplicates",
                        "type": "boolean",
                        "description": "Avoid saving the same SoundCloud track more than once in the same run.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```