# YouTube Music to MP3 Audio Downloader (`lurkapi/youtube-music-to-mp3-audio-downloader`) Actor

Download audio from YouTube Music as MP3, M4A, WAV, FLAC, AAC, OPUS, Vorbis, or ALAC. Paste one or more links, pick format and bitrate, get direct download links. Supports playlists, regular YouTube, and batch processing.

- **URL**: https://apify.com/lurkapi/youtube-music-to-mp3-audio-downloader.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 minute downloadeds

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

## YouTube Music to MP3 Audio Downloader

Download audio from YouTube Music tracks as MP3, M4A, WAV, FLAC, AAC, OPUS, Vorbis, or ALAC. Paste your links, choose a format and quality, and get direct download links to your audio files.

### 🎵 What it does

Give it one or more YouTube Music links, and it will:

1. **Extract the audio** from each track in your chosen format and bitrate
2. **Save the audio files** to your Apify storage with direct download links
3. **Grab track details** like artist name, title, duration, view count, and more
4. **Save the thumbnails** (album art) with direct download links

Works with YouTube Music URLs, regular YouTube videos, Shorts, and playlists. Just copy the link from the YouTube Music app or website.

### 🎧 Real file downloads, not temporary links

Unlike most YouTube Music tools that only give you temporary Google CDN links (which expire within hours and get blocked when fetched from a backend server), this Actor **fully downloads the audio file** and stores it in your Apify storage. You get a direct download URL that:

- Works from any server, any IP, any time
- Is safe for backend integrations, automation pipelines, and programmatic access
- Can be shared directly as a download link
- Stored in your Apify storage (retention depends on your Apify plan)

### 📋 How to use it

#### Step 1: Paste your links and choose options

Add your YouTube Music URLs and select format/quality in the input. You can add up to 1,000 URLs at a time.

```json
{
    "videoUrls": [
        "https://music.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=9bZkp7q19f0"
    ],
    "audioFormat": "mp3",
    "audioBitrate": "192k",
    "maxConcurrency": 3
}
````

**Supported URL types:**

- YouTube Music: `music.youtube.com/watch?v=...`
- YouTube Music playlists: `music.youtube.com/playlist?list=...`
- Regular YouTube: `youtube.com/watch?v=...`
- Short links: `youtu.be/...`
- Shorts: `youtube.com/shorts/...`
- Playlists: `youtube.com/playlist?list=...` (auto-expanded into individual tracks)

#### Step 2: Run it

Click **Start** and wait for it to finish. Audio extraction is fast: most songs finish in under 30 seconds.

#### Step 3: Get your files

Once it's done, check the **Output** tab. Each result includes:

- **status**: "Success" or a message explaining what went wrong and what to do about it
- **audioFileUrl**: Direct download link to the audio file in your Apify storage
- **thumbnailFileUrl**: Direct download link to the thumbnail/album art
- **title**, **channel**, **duration**, **uploadDate**: Track metadata
- **audioFormat**, **audioBitrate**: The format and quality used
- **fileSize**: File size in bytes
- **stats**: Views, likes, and comments

#### Example output

```json
{
    "status": "Success",
    "videoId": "dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up (Official Music Video)",
    "channel": "Rick Astley",
    "duration": 212,
    "uploadDate": "2009-10-25",
    "audioFileUrl": "https://api.apify.com/v2/key-value-stores/.../records/audio-dQw4w9WgXcQ",
    "thumbnailFileUrl": "https://api.apify.com/v2/key-value-stores/.../records/thumbnail-dQw4w9WgXcQ",
    "audioFormat": "mp3",
    "audioBitrate": "192k",
    "fileSize": 3407872
}
```

### 🎶 Audio format options

This Actor supports 8 audio formats to cover every use case:

| Format | Type | Best for |
|--------|------|----------|
| **MP3** | Compressed | Most compatible format, works on every device and player |
| **M4A (AAC)** | Compressed | Better quality than MP3 at the same bitrate, great for Apple devices |
| **AAC** | Compressed | Advanced audio codec, widely supported on mobile devices |
| **OPUS** | Compressed | Modern format with excellent quality at low bitrates, great for streaming |
| **Vorbis** | Compressed | Open-source format, good quality at moderate bitrates |
| **FLAC** | Lossless | Compressed lossless audio, studio quality at half the size of WAV |
| **WAV** | Lossless | Uncompressed audio, large files, best for editing and production |
| **ALAC** | Lossless | Apple Lossless, perfect for Apple devices and iTunes |

**Quality options:** auto (best available), 320k (highest), 256k, 192k (default), 128k, 64k. Lossless formats (WAV, FLAC, ALAC) always produce full-quality audio regardless of this setting.

### 🌐 Proxy settings

By default, the Actor uses Apify's datacenter proxies.

- **Automatic (default)**: Apify selects the best proxy.
- **Datacenter**: Fast and cheap. Works for popular tracks, but YouTube may block some requests.
- **Residential**: Use if you get frequent "sign-in challenge" blocks. Most reliable for all tracks.
- **Own proxies**: Provide your own proxy URLs.
- **No proxy**: Disable proxies. Not recommended for YouTube.

### 💰 Pricing

This Actor charges per minute of audio downloaded. You only pay for successful downloads. Failed extractions are free.

The price per minute is shown on the Actor's pricing card above.

**Example:** A 3.5-minute song counts as 4 minutes (rounded up).

### 💡 Good to know

- **Proxy recommended:** YouTube blocks most requests from datacenter IPs. If you see "YouTube is blocking this request", switch to **Residential** proxy.
- **Age-restricted tracks** cannot be downloaded. They require a logged-in YouTube account, which this Actor does not have.
- **Private tracks** cannot be downloaded. You'll get a clear error message.
- **Playlists** are automatically expanded into individual tracks.
- **Shorts** work just like regular videos.
- Short links (`youtu.be/...`) are resolved automatically.
- Duplicate URLs are automatically removed.
- Up to 1,000 URLs per run.
- WAV files are large (about 10 MB per minute of audio). For most uses, MP3, M4A, or FLAC is recommended.
- Audio files are stored in your Apify storage. How long they're kept depends on your Apify plan.
- YouTube Music URLs and regular YouTube URLs both work. The same track is available on both platforms.

### ❓ FAQ

**Why did my download fail?**
The most common reason is YouTube blocking the request. Switch to **Residential** proxy in the Proxy configuration input. If the track is age-restricted or private, it cannot be downloaded.

**Which format should I choose?**

- **MP3** for maximum compatibility (works on every device and player)
- **M4A** for better quality at the same file size (ideal for Apple devices)
- **FLAC** for lossless quality at a reasonable file size (ideal for audiophiles)
- **WAV** for uncompressed lossless audio (ideal for editing, production, or sampling)
- **OPUS** for best quality at low bitrates (ideal for streaming or storage-constrained use)
- **ALAC** for lossless audio on Apple devices (ideal for iTunes and Apple Music libraries)

**Which bitrate should I choose?**
192k is a good default for most uses. Choose 320k if you want the highest quality. Choose 128k for smaller files. Choose "auto" to let the tool pick the best available quality. Lossless formats (WAV, FLAC, ALAC) ignore the bitrate setting entirely.

**How long are the files stored?**
Audio files are stored in your Apify storage. How long they're kept depends on your Apify plan. Check your plan details for retention periods.

**Can I download private tracks?**
No. Private tracks require a logged-in YouTube account, which this Actor does not have. You'll see a clear error message in the output.

**Is there a file size limit?**
Audio files are capped at 500 MB. Compressed formats like MP3 and M4A are small (about 1 MB per minute at 128k). WAV files are larger (about 10 MB per minute). For very long recordings, use a compressed format instead of WAV.

**Can I use this from my backend?**
Yes. The `audioFileUrl` is a direct download URL stored in your Apify storage. Unlike Google CDN links, it works from any IP and any server. This is specifically designed for backend integrations and automation. Call the Actor via the [Apify API](https://docs.apify.com/api/v2) and read the dataset items to get the download URLs.

**Do YouTube Music URLs work differently from regular YouTube URLs?**
No. YouTube Music and YouTube share the same audio content. A track available on YouTube Music can also be accessed via a regular YouTube URL, and vice versa. This Actor handles both seamlessly.

### 🔗 Other tools you might like

- [YouTube to MP3 Audio Downloader](https://apify.com/nik_crespin/youtube-to-mp3-audio-downloader) - Download audio from any YouTube video as MP3, M4A, or WAV.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with YouTube's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on YouTube at run time.

**Keywords:** youtube music downloader, youtube music to mp3, youtube music audio downloader, download youtube music, youtube music mp3 converter, youtube music flac, youtube music wav, youtube music offline

# Actor input Schema

## `videoUrls` (type: `array`):

Paste your YouTube Music or YouTube links here. Supports music.youtube.com URLs, regular YouTube videos, short links (youtu.be/...), Shorts, and playlist URLs.

## `audioFormat` (type: `string`):

Select the audio output format. MP3 is the most compatible. M4A (AAC) has better quality at the same bitrate. FLAC and WAV are lossless. OPUS and Vorbis are efficient compressed formats. ALAC is Apple's lossless format.

## `audioBitrate` (type: `string`):

Select audio bitrate. Higher values mean better quality and larger files. Lossless formats (WAV, FLAC, ALAC) ignore this setting. 'auto' lets the tool pick the best available quality.

## `proxyConfiguration` (type: `object`):

Select proxy to route requests through YouTube. Recommended for reliable downloads.

## `maxConcurrency` (type: `integer`):

Maximum number of audio files to download in parallel.

## Actor input object example

```json
{
  "videoUrls": [
    "https://music.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "audioFormat": "mp3",
  "audioBitrate": "192k",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "videoUrls": [
        "https://music.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "audioFormat": "mp3",
    "audioBitrate": "192k",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/youtube-music-to-mp3-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 = {
    "videoUrls": ["https://music.youtube.com/watch?v=dQw4w9WgXcQ"],
    "audioFormat": "mp3",
    "audioBitrate": "192k",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/youtube-music-to-mp3-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 '{
  "videoUrls": [
    "https://music.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "audioFormat": "mp3",
  "audioBitrate": "192k",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-music-to-mp3-audio-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Music to MP3 Audio Downloader",
        "description": "Download audio from YouTube Music as MP3, M4A, WAV, FLAC, AAC, OPUS, Vorbis, or ALAC. Paste one or more links, pick format and bitrate, get direct download links. Supports playlists, regular YouTube, and batch processing.",
        "version": "0.0",
        "x-build-id": "sY88cjdbwxCF4uekl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-music-to-mp3-audio-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-music-to-mp3-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/lurkapi~youtube-music-to-mp3-audio-downloader/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-music-to-mp3-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/lurkapi~youtube-music-to-mp3-audio-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-music-to-mp3-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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "YouTube Music URLs",
                        "type": "array",
                        "description": "Paste your YouTube Music or YouTube links here. Supports music.youtube.com URLs, regular YouTube videos, short links (youtu.be/...), Shorts, and playlist URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "audioFormat": {
                        "title": "Audio Format",
                        "enum": [
                            "mp3",
                            "m4a",
                            "wav",
                            "aac",
                            "flac",
                            "opus",
                            "vorbis",
                            "alac"
                        ],
                        "type": "string",
                        "description": "Select the audio output format. MP3 is the most compatible. M4A (AAC) has better quality at the same bitrate. FLAC and WAV are lossless. OPUS and Vorbis are efficient compressed formats. ALAC is Apple's lossless format.",
                        "default": "mp3"
                    },
                    "audioBitrate": {
                        "title": "Audio Quality (Bitrate)",
                        "enum": [
                            "auto",
                            "320k",
                            "256k",
                            "192k",
                            "128k",
                            "64k"
                        ],
                        "type": "string",
                        "description": "Select audio bitrate. Higher values mean better quality and larger files. Lossless formats (WAV, FLAC, ALAC) ignore this setting. 'auto' lets the tool pick the best available quality.",
                        "default": "192k"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxy to route requests through YouTube. Recommended for reliable downloads.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of audio files to download in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
