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

Download YouTube audio as MP3, AAC (M4A), or WAV. Paste one or more links, pick format and bitrate, get permanent download links. Supports playlists, Shorts, and batch processing.

- **URL**: https://apify.com/lurkapi/youtube-to-mp3-audio-downloader.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 1 total users, 0 monthly users, 100.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 to MP3 Audio Downloader

Download audio from any YouTube video as MP3, AAC (M4A), or WAV. Paste one or more links, pick your format and quality, get permanent download links.

### What it does

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

1. **Extract the audio** from each video in your chosen format and bitrate
2. **Save the audio files** to your Apify storage with permanent download links
3. **Grab video details** like the channel name, title, duration, view count, and more
4. **Save the thumbnails** with permanent links

Works with any public YouTube video, Shorts, and playlists. Just copy the link from the YouTube app or website.

### Real file downloads, not redirect links

Unlike most YouTube audio 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 permanent URL that:

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

### How to use it

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

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

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

**Format options:**

- **MP3**: Most compatible format, works everywhere
- **M4A (AAC)**: Better quality than MP3 at the same bitrate, great for Apple devices
- **WAV**: Uncompressed audio, large files, best for editing and production

**Quality options:** 320k (highest), 256k, 192k (default), 128k. WAV is always uncompressed regardless of this setting.

**Supported URL types:**

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

#### 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**: Permanent link to the audio file in your Apify storage
- **thumbnailFileUrl**: Permanent link to the thumbnail image
- **title**, **channel**, **duration**, **uploadDate**: Video 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
}
```

### 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 videos, but YouTube may block some requests.
- **Residential**: Use if you get frequent "sign-in challenge" blocks. Most reliable for all videos.
- **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 videos** cannot be downloaded. They require a logged-in YouTube account, which this Actor does not have.
- **Private videos** cannot be downloaded. You'll get a clear error message.
- **Playlists** are automatically expanded into individual videos.
- **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 or M4A is recommended.
- Audio files are stored in your Apify storage. How long they're kept depends on your Apify plan.

### 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 video 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)
- **WAV** for lossless audio (ideal for editing, production, or sampling)

**Which bitrate should I choose?**
192k is a good default for most uses. Choose 320k if you want the highest quality MP3/M4A. Choose 128k if you want smaller files and don't mind lower quality.

**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 videos?**
No. Private videos 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. MP3 and M4A files are small (about 1 MB per minute at 128k). WAV files are larger (about 10 MB per minute). For very long recordings, use MP3 or M4A instead of WAV.

**Can I use this from my backend?**
Yes. The `audioFileUrl` is a permanent URL stored on Apify's servers. 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.

### 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 to mp3, youtube audio downloader, youtube mp3 converter, youtube audio extractor, download youtube audio, youtube m4a, youtube music downloader

# Actor input Schema

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

Paste your YouTube links here. Supports video URLs, short links (youtu.be/...), Shorts, and playlist URLs.

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

Select the audio output format. MP3 is the most compatible. AAC (M4A) has better quality at the same bitrate. WAV is uncompressed and produces large files.

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

Select audio bitrate. Higher values mean better quality and larger files. WAV is always uncompressed regardless of this setting.

## `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://www.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://www.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-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://www.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-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://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "audioFormat": "mp3",
  "audioBitrate": "192k",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-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-to-mp3-audio-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube to MP3 Audio Downloader",
        "description": "Download YouTube audio as MP3, AAC (M4A), or WAV. Paste one or more links, pick format and bitrate, get permanent download links. Supports playlists, Shorts, and batch processing.",
        "version": "0.0",
        "x-build-id": "H3Yd6DGjIcsdVlajy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-to-mp3-audio-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-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-to-mp3-audio-downloader/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-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-to-mp3-audio-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-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 URLs",
                        "type": "array",
                        "description": "Paste your YouTube links here. Supports video URLs, short links (youtu.be/...), Shorts, and playlist URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "audioFormat": {
                        "title": "Audio Format",
                        "enum": [
                            "mp3",
                            "m4a",
                            "wav"
                        ],
                        "type": "string",
                        "description": "Select the audio output format. MP3 is the most compatible. AAC (M4A) has better quality at the same bitrate. WAV is uncompressed and produces large files.",
                        "default": "mp3"
                    },
                    "audioBitrate": {
                        "title": "Audio Quality (Bitrate)",
                        "enum": [
                            "320k",
                            "256k",
                            "192k",
                            "128k"
                        ],
                        "type": "string",
                        "description": "Select audio bitrate. Higher values mean better quality and larger files. WAV is always uncompressed regardless of this setting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```