# Bandcamp Scraper (`goat255/bandcamp-scraper`) Actor

Scrape Bandcamp artists, albums, and tracks without a login. Search by keyword, pull a release with its full tracklist, prices, tags, and cover art, or list an artist's whole discography. Music metadata only.

- **URL**: https://apify.com/goat255/bandcamp-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** E-commerce, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

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

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

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


# README

## Bandcamp Scraper

Scrape Bandcamp artists, albums, and tracks with no login and no API key. Search by keyword, pull a release with its full tracklist, prices, tags, and cover art, or list an artist's entire discography as clean structured data.

This Bandcamp Scraper extracts public music metadata at scale: artist profiles, album and track details, per-track durations, pricing, currency, tags, cover art, release dates, and discography listings. Give it search terms, release links, or artist links and it returns normalized JSON rows ready for export to CSV, Excel, JSON, or your database.

### What it does

- **Keyword search** across artists, albums, and tracks. Returns a typed list of matches with names, artists, locations, genres, and links.
- **Album and track extraction** from any release URL. Returns title, artist, release date, price and currency, tags, cover art, credits, and the full tracklist with per-track durations and streamable/downloadable flags.
- **Artist discography** from any artist URL. Returns the artist's name, location, bio, links, header image, and a complete listing of every release in their catalog (not just the first page).
- **Optional release expansion**: turn each release in a discography into its own full metadata row (tracklist, prices, tags) in a single run.
- **No account, no password, no API key.** Works straight out of the box.
- **Clean, ordered output**: every row is a flat, consistently keyed object, with identity fields first and metadata last.

### Use cases

- **Music market research**: track pricing, release cadence, tags, and catalog size across labels and genres.
- **Catalog and metadata ingestion**: build or enrich a music database with structured release and tracklist data.
- **A&R and talent discovery**: search by genre or keyword to surface emerging artists and their discographies.
- **Price and release monitoring**: schedule runs to watch when an artist or label drops a new release or changes pricing.
- **Playlist and recommendation pipelines**: feed normalized track and album metadata into your own apps.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array of strings | Keyword searches to run across artists, albums, and tracks. |
| `albumUrls` | array of strings | Album or track page links to fetch with their full tracklist, prices, tags, and cover art. |
| `artistUrls` | array of strings | Artist page links to fetch with their full discography listing. |
| `maxResultsPerQuery` | integer | Cap on search results returned per query (1 to 50). Default 50. |
| `maxReleasesPerArtist` | integer | Cap on releases listed per artist discography (1 to 1000). Default 100. |
| `expandArtistReleases` | boolean | When on, each release in a discography is also fetched as its own full album or track row. Default off. |
| `concurrency` | integer | How many sources to process in parallel (1 to 20). Default 5. |
| `proxyConfig` | object | Optional proxy configuration. Not required. |

You can combine any of the three modes in a single run.

#### Example input

```json
{
  "searchQueries": ["ambient techno", "lo-fi"],
  "albumUrls": ["https://example.bandcamp.com/album/example-album"],
  "artistUrls": ["https://example.bandcamp.com"],
  "maxResultsPerQuery": 50,
  "maxReleasesPerArtist": 200,
  "expandArtistReleases": false
}
````

### Output

Each result is a clean object whose `type` field is one of `album`, `track`, `artist`, or `searchResult`. Keys are ordered by importance: identity first, then metrics, content, media, and metadata.

A sample album row:

```json
{
  "type": "album",
  "id": 1234567890,
  "url": "https://example.bandcamp.com/album/example-album",
  "title": "Example Album",
  "artist": "Acme Co",
  "artistUrl": "https://example.bandcamp.com",
  "price": 9.99,
  "currency": "USD",
  "numTracks": 2,
  "isFreeDownload": false,
  "isPreorder": false,
  "tags": ["ambient", "techno"],
  "about": "Liner notes for the release.",
  "credits": "Written and produced by Acme Co",
  "copyright": "All Rights Reserved",
  "coverArt": "https://example.com/cover.jpg",
  "releaseDate": "2026-01-01T00:00:00.000Z",
  "publishDate": "2026-01-01T00:00:00.000Z",
  "hasAudio": true,
  "tracks": [
    {
      "trackNumber": 1,
      "title": "Example Track",
      "durationSeconds": 215,
      "hasLyrics": false,
      "isStreamable": true,
      "isDownloadable": true,
      "url": "https://example.bandcamp.com/track/example-track"
    }
  ],
  "scrapedAt": "2026-06-18T00:00:00.000Z"
}
```

Key fields:

- `type` tells you which row shape you are looking at (`album`, `track`, `artist`, `searchResult`).
- `price` and `currency` reflect the release's minimum price at scrape time; `isFreeDownload` flags name-your-price or free releases.
- `tags` is the release's genre and mood tags. `tracks` is the full tracklist with per-track duration in seconds.
- An **artist** row carries `name`, `location`, `numReleases`, `bio`, `links`, `coverArt`, and a `releases` listing of `{ itemType, title, artist, url }`.
- A **search result** row carries `kind` (artist, album, or track), `name`, `artist`, `url`, `location`, and `genre`.

### FAQ

**Is it free? How is it priced?**
The actor runs on Apify's pay-as-you-go model. You only pay for the compute and results of your own runs. There is no separate Bandcamp subscription or fee.

**Do I need a Bandcamp login or API key?**
No. It works entirely against public pages and a public search endpoint. No account, password, or key is required.

**How many results can I get per run?**
Search returns up to 50 results per query. Artist discography returns the full catalog up to `maxReleasesPerArtist` (up to 1000), and the complete listing is read in one pass, not just the first visible page. You can pass many search queries, album URLs, and artist URLs in a single run.

**How fast is it?**
Sources are processed in parallel using the `concurrency` setting (default 5). A search query or a single release resolves in a second or two; a large discography expansion scales with the number of releases and your concurrency.

**Does it collect song lyrics?**
No. Track entries carry metadata only (title, number, duration, and a boolean for whether lyrics exist on the page). Full lyrics are not collected or stored.

**Can I export the data?**
Yes. Results are stored in an Apify dataset and can be exported to JSON, CSV, Excel, or HTML, or pulled via the API.

**Why is `about`, `credits`, `location`, or `genre` sometimes empty?**
These are optional fields that not every artist or release fills in. When the value exists on the source page it is captured; when the artist left it blank, the field is returned empty.

### Notes

- Prices and tags reflect the values shown on the release page at scrape time.
- `maxReleasesPerArtist` and `maxResultsPerQuery` cap how much each source returns.
- Standard Bandcamp subdomain URLs are the most reliable input. Custom artist domains usually work too.

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword searches to run across Bandcamp artists, albums, and tracks. Example: ambient techno, lo-fi.

## `albumUrls` (type: `array`):

Album or track page links to fetch with their full tracklist, prices, tags, and cover art. Example: https://example.bandcamp.com/album/example-album.

## `artistUrls` (type: `array`):

Artist page links to fetch with their discography listing. Example: https://example.bandcamp.com.

## `maxResultsPerQuery` (type: `integer`):

Cap on the number of search results returned per query.

## `maxReleasesPerArtist` (type: `integer`):

Cap on the number of releases listed per artist discography.

## `expandArtistReleases` (type: `boolean`):

When on, each release in an artist's discography is also fetched as its own full album or track row (tracklist, prices, tags). Slower, but returns complete metadata for the whole catalog.

## `concurrency` (type: `integer`):

How many sources to process in parallel.

## `proxyConfig` (type: `object`):

Optional proxy. The public endpoints do not require a proxy, but you may route through one if you wish.

## Actor input object example

```json
{
  "searchQueries": [
    "ambient techno"
  ],
  "albumUrls": [],
  "artistUrls": [],
  "maxResultsPerQuery": 50,
  "maxReleasesPerArtist": 100,
  "expandArtistReleases": false,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQueries": [
        "ambient techno"
    ],
    "albumUrls": [],
    "artistUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/bandcamp-scraper").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 = {
    "searchQueries": ["ambient techno"],
    "albumUrls": [],
    "artistUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/bandcamp-scraper").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 '{
  "searchQueries": [
    "ambient techno"
  ],
  "albumUrls": [],
  "artistUrls": []
}' |
apify call goat255/bandcamp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Scraper",
        "description": "Scrape Bandcamp artists, albums, and tracks without a login. Search by keyword, pull a release with its full tracklist, prices, tags, and cover art, or list an artist's whole discography. Music metadata only.",
        "version": "0.1",
        "x-build-id": "ZTKKjFLRZYnNXMf7b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~bandcamp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-bandcamp-scraper",
                "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/goat255~bandcamp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-bandcamp-scraper",
                "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/goat255~bandcamp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-bandcamp-scraper",
                "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",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries (search mode)",
                        "type": "array",
                        "description": "Keyword searches to run across Bandcamp artists, albums, and tracks. Example: ambient techno, lo-fi.",
                        "default": [
                            "ambient techno"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "albumUrls": {
                        "title": "Album or track URLs (release mode)",
                        "type": "array",
                        "description": "Album or track page links to fetch with their full tracklist, prices, tags, and cover art. Example: https://example.bandcamp.com/album/example-album.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "artistUrls": {
                        "title": "Artist URLs (discography mode)",
                        "type": "array",
                        "description": "Artist page links to fetch with their discography listing. Example: https://example.bandcamp.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap on the number of search results returned per query.",
                        "default": 50
                    },
                    "maxReleasesPerArtist": {
                        "title": "Max releases per artist",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on the number of releases listed per artist discography.",
                        "default": 100
                    },
                    "expandArtistReleases": {
                        "title": "Expand artist releases into full rows",
                        "type": "boolean",
                        "description": "When on, each release in an artist's discography is also fetched as its own full album or track row (tracklist, prices, tags). Slower, but returns complete metadata for the whole catalog.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many sources to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The public endpoints do not require a proxy, but you may route through one if you wish.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```