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

🎵 Bandcamp Audio Downloader downloads your favorite tracks with ease—fast, reliable, and user-friendly. Save & enjoy music offline anytime. 🚀 Perfect for fans, collectors, and creators who want seamless Bandcamp audio access.

- **URL**: https://apify.com/scraperoka/bandcamp-audio-downloader.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Automation, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Bandcamp Audio Downloader ⚡

Manually visiting Bandcamp tracks to collect audio stream links and track metadata wastes hours you don’t have. **Bandcamp Audio Downloader** extracts high-quality audio stream details and metadata from the Bandcamp track URLs you provide. It’s ideal for marketers, recruiters, and growth teams that want a faster **Bandcamp audio downloader**, **Bandcamp track downloader**, or **Bandcamp album downloader** workflow—at scale. You can process multiple tracks in a single run and push the results to your Apify dataset in minutes.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

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

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The Bandcamp track URL that was processed in this record |
| `result` | object | The extracted output (or error details) for that specific URL |
| `result.url` | string | The same track URL, stored alongside the extraction output |
| `result.title` | string | A combined title built from track name + artist (or fallback to the extracted title) |
| `result.source` | string | Indicates the origin of the data (`"bandcamp"`) |
| `result.thumbnail` | string | The track thumbnail URL (empty string when not available) |
| `result.duration` | number | Track duration in seconds (or `0` if missing) |
| `result.medias` | array | A list of audio media entries found for the track |
| `result.medias[].url` | string | Direct audio stream URL for the extracted media |
| `result.medias[].quality` | string | Audio quality label (e.g. `"HQ"`) |
| `result.medias[].extension` | string | File extension hint derived from the extraction result |
| `result.medias[].type` | string | Media type label (e.g. `"audio"`) |
| `result.type` | string | Output type for this record (`"single"`) |
| `result.error` | boolean | `false` when extraction succeeded; `true` when it failed |
| `result.message` | string | Present only when `error` is `true`, contains the error text |
| `result.time_end` | number | A time value included in the result payload |

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

***

### Why Bandcamp Audio Downloader?

There are a lot of ways to pull data from Bandcamp tracks — here’s what sets Bandcamp Audio Downloader apart.

#### Built for track-to-output workflows

Bandcamp Audio Downloader is designed to take a list of track URLs and return structured metadata plus audio stream links in one go. It’s a practical Bandcamp audio ripper workflow for anyone building a track catalog or offline listening pipeline.

#### Clean, integration-ready result structure

Each processed URL produces a consistent JSON record with a dedicated `result` object, including `title`, `thumbnail`, `duration`, and a `medias` array. This makes it easy to pipe into analysis, enrichment, or downstream automation for a Bandcamp download tool setup.

#### Resilient extraction with error handling

If a track can’t be extracted, you still get a result record with `result.error: true` and a `result.message` explaining the issue. That means you can review failures without losing context for successes.

#### Dataset-ready at the end of the run

After processing your list of Bandcamp track URLs, the actor pushes the full results to your Apify dataset (`charged_event_name="result"`). This is especially useful for bulk tasks like a Bandcamp bulk downloader or Bandcamp track downloader for research.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---:|---|
| `urls` | ✅ | A list of Bandcamp track URLs to scrape and extract audio stream details + metadata from |

***

### Core Capabilities

#### Audio stream extraction + HQ media links

For each provided Bandcamp track URL, Bandcamp Audio Downloader extracts the best available audio stream and returns it in `result.medias` as a structured entry. This is useful when you’re trying to “download Bandcamp tracks offline” into a controlled workflow.

#### Track metadata included (title, thumbnail, duration)

Alongside audio stream details, you get metadata fields like `result.title`, `result.thumbnail`, and `result.duration`. This helps you build richer outputs than a basic Bandcamp mp3 downloader that only returns links.

#### Flexible batch processing via `urls`

You can submit many Bandcamp track URLs in the `urls` array and process them within a single run. That makes it a strong Bandcamp album downloader-style tool for collections and bulk lists (even when inputs are track-level).

#### Clear success/failure status per URL

Every input URL produces a corresponding record in the pushed output, with `result.error` indicating whether extraction succeeded. When it fails, `result.message` is included so you can troubleshoot without rerunning everything blindly.

#### Ready for automation and exports

The actor pushes results to your Apify dataset and you can export them in formats like JSON, CSV, or Excel from the Apify dashboard. This supports everything from a Bandcamp download software workflow to analyst-friendly dataset exports.

***

### Who Gets the Most Out of This

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

**Music marketers and content ops** — Use it to build organized track lists with consistent titles, thumbnails, and durations, then export the dataset for planning playlists, campaigns, and release tracking without manually copying links.

**Researchers and data analysts** — Turn a set of Bandcamp track URLs into structured records suitable for analysis, comparison, and dataset enrichment, with clear per-URL success (`result.error: false`) and failure (`result.error: true`) states.

**Automation specialists and developers** — Integrate the actor’s dataset output into pipelines that ingest audio stream links and metadata for further processing, reporting, or internal systems.

**Community and curator teams** — Use it as a Bandcamp track downloader foundation to assemble track catalogs faster, keeping the output consistent across many inputs and avoiding manual data entry.

***

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

No coding needed. Here's how to run Bandcamp Audio Downloader from start to finish:

1. **Open the actor on Apify** — Go to Apify Console and find **Bandcamp Audio Downloader**.
2. **Enter your inputs** — Paste one or more Bandcamp track URLs into the `urls` field.
3. **Configure proxy settings (optional)** — If your run requires enhanced reliability, set your proxy configuration in the run settings.
4. **Hit Run and watch the live log** — Monitor progress as each provided URL is processed.
5. **View results in the dataset tab** — Open the dataset to inspect the extracted `result` records for each track.
6. **Export as JSON, CSV, or Excel** — Download from the Apify dataset view for your preferred workflow.
7. **Refine and re-run as needed** — If some URLs error, you can adjust your list and run again.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export your dataset from the Apify dashboard as JSON, CSV, or Excel. This makes it straightforward to use the output for a Bandcamp audio downloader workflow in spreadsheets, BI tools, or manual research.

You can also connect your actor runs to automation workflows using Apify’s API access and supported integration paths like webhooks and no-code tools. For deeper setup details, refer to the Apify documentation: https://apify.com/docs/api.

***

### Pricing & Free Trial

Bandcamp Audio Downloader runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

In general, you can expect pay-as-you-go usage billed by Apify platform compute units (CU) rather than a per-result row fee. For current limits, trial credits, and plan details, check the Apify pricing page.

Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits and stability | Uses built-in request support to keep extraction reliable across longer lists |
| Proxy support | Built-in proxy support helps improve reliability for scraping tasks |
| Per-URL failures | Errors are captured per record using `result.error` and `result.message` |
| Data completeness | Each processed input URL returns a corresponding output record |
| Batch processing | Processes multiple URLs in one run and pushes results to the dataset |

**Limitations:** Bandcamp Audio Downloader works on the Bandcamp track pages you provide as publicly available inputs. If a track can’t be extracted for any reason, that URL will return an error record instead of stopping the entire run.

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

***

### Frequently Asked Questions

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

Yes. Bandcamp Audio Downloader runs on the Apify platform, which offers a **free tier** so you can try test runs before scaling up.

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

No. This actor is designed to work from the Bandcamp track URLs you provide and extract available stream and metadata data without requiring login.

#### How accurate is the data?

The extracted fields come directly from the track extraction process and include items like `result.title`, `result.thumbnail`, `result.duration`, and `result.medias`. If extraction can’t be completed for a URL, the output will include `result.error: true` and `result.message`.

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

Your results are generated for each URL you pass in the `urls` array. If you include more track URLs, you’ll typically get more records pushed to the dataset for that run.

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

Data freshness depends on when you run the actor and what the track’s page exposes at that time. If you need updated stream URLs or metadata, re-run with the current list of track URLs.

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

It’s based on **publicly available data** available on the provided Bandcamp track URLs. You’re responsible for ensuring your usage complies with GDPR, CCPA, and relevant platform rules.

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

Yes. You can export your dataset from the Apify dashboard in common formats like JSON, CSV, or Excel, and then import into Google Sheets or other spreadsheet tools.

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

Yes. You can set up scheduled runs using Apify’s scheduling capabilities, so Bandcamp Audio Downloader runs automatically on a regular cadence.

#### Can I access this via API?

Yes. You can access run results programmatically using Apify’s API. For documentation, see https://apify.com/docs/api.

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

If an error occurs for a specific track URL, the actor returns a record with `result.error: true` and a `result.message` for that URL. Successful URLs are still returned in the same dataset output.

***

### Need Help or Have a Request?

Got a question about Bandcamp Audio Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome feedback from users and actively maintain this actor based on requests—one idea we’re often asked about is webhook notifications on completion and support for more batch input formats.

***

### Disclaimer & Responsible Use

*Bandcamp Audio Downloader is the fastest, most reliable way to extract Bandcamp audio stream details and metadata — start your free run today.*

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

# Actor input Schema

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

List of Bandcamp track URLs to scrape.

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/bandcamp-audio-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/bandcamp-audio-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call scraperoka/bandcamp-audio-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Audio Downloader",
        "description": "🎵 Bandcamp Audio Downloader downloads your favorite tracks with ease—fast, reliable, and user-friendly. Save & enjoy music offline anytime. 🚀 Perfect for fans, collectors, and creators who want seamless Bandcamp audio access.",
        "version": "0.1",
        "x-build-id": "IDZCnTYV3oQaGO3RU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~bandcamp-audio-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-bandcamp-audio-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~bandcamp-audio-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-bandcamp-audio-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~bandcamp-audio-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-bandcamp-audio-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Bandcamp Track URLs",
                        "type": "array",
                        "description": "List of Bandcamp track URLs to scrape.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://emilyhenry.bandcamp.com/track/oh-no"
                        ]
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
