# MusicBrainz Artist & Release Lookup (Free) (`fit_melon/musicbrainz-artist-release-lookup`) Actor

Bulk artist and discography lookup from MusicBrainz, the open music encyclopedia. Get MBID, country, genres/tags, life span and all release groups (albums, EPs, singles) as clean JSON. Free music data enrichment.

- **URL**: https://apify.com/fit\_melon/musicbrainz-artist-release-lookup.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## MusicBrainz Artist & Release Lookup (Free)

Bulk **artist lookup and discography scraper** powered by [MusicBrainz](https://musicbrainz.org), the open music encyclopedia. Give it a list of artist or band names and it returns clean, structured JSON for each one: **MBID**, country, artist type, gender, tags/genres, life span, ISNI/IPI identifiers, and the full list of **release groups** (albums, EPs, singles) sorted by first release date.

Ideal for **music data enrichment**, building a music catalogue, deduplicating artist names against a canonical ID, or feeding an LLM/RAG pipeline with reliable music metadata. This actor is **100% free** — you only pay your own Apify platform usage.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `artists` | array of strings | *(required)* | Artist or band names to look up. One dataset item per name. |
| `includeReleaseGroups` | boolean | `true` | Also fetch the artist's albums, EPs and singles. |
| `maxReleaseGroups` | integer | `25` | Max release groups returned per artist (1–100). |

### Output

One dataset item per input name, always with an explicit `status` field (`found`, `not_found` or `error`) — the actor never crashes on a bad name.

```json
{
  "status": "found",
  "query": "Daft Punk",
  "mbid": "056e4f3e-d505-4dad-8ec1-d04f521cbb56",
  "name": "Daft Punk",
  "sortName": "Daft Punk",
  "type": "Group",
  "disambiguation": "French electronic duo",
  "country": "FR",
  "area": "France",
  "beginArea": "Paris",
  "lifeSpanBegin": "1993",
  "lifeSpanEnd": "2021",
  "ended": true,
  "isnis": ["0000000123456789"],
  "tags": ["electronic", "house"],
  "matchScore": 100,
  "musicbrainzUrl": "https://musicbrainz.org/artist/056e4f3e-d505-4dad-8ec1-d04f521cbb56",
  "releaseGroupCount": 2,
  "releaseGroups": [
    {
      "mbid": "1c205a81-1d1c-3b4d-8b1e-6b0b0a0a0a0a",
      "title": "Homework",
      "primaryType": "Album",
      "secondaryTypes": [],
      "firstReleaseDate": "1997-01-20",
      "url": "https://musicbrainz.org/release-group/1c205a81-1d1c-3b4d-8b1e-6b0b0a0a0a0a"
    }
  ],
  "error": null
}
````

### Use cases

- **Enrich a music library or playlist** with canonical MBIDs, genres and countries.
- **Resolve messy artist names** from a CRM, ticketing or streaming export to one stable identifier.
- **Build a discography dataset** for analytics, recommendation or research.
- **Feed an AI agent / RAG index** with trustworthy, licence-clean music metadata.

### Limitations & fair use

- Data comes from the MusicBrainz web service. Core data is public domain (CC0); supplementary data is CC BY-NC-SA — check the [MusicBrainz licence](https://musicbrainz.org/doc/About/Data_License) before commercial redistribution.
- MusicBrainz allows **max 1 request per second** per client. This actor respects that limit with a built-in delay, so large lists take roughly 1–2 seconds per artist. This is intentional and keeps the service healthy for everyone.
- Search returns the best match for a name. For guaranteed precision, prefer exact official spellings.
- Network calls retry up to 3 times with backoff; unrecoverable failures are reported as an `error` item rather than crashing the run.

### More actors by this developer

Browse the full collection of free data and enrichment actors: **[apify.com/fit\_melon](https://apify.com/fit_melon)**

# Actor input Schema

## `artists` (type: `array`):

List of artist or band names to look up on MusicBrainz. One dataset item is produced per name. Example: Daft Punk, Radiohead, Miles Davis.

## `includeReleaseGroups` (type: `boolean`):

If enabled, fetches the artist's albums, EPs and singles (release groups) sorted by first release date. Adds one extra request per artist.

## `maxReleaseGroups` (type: `integer`):

Maximum number of release groups (albums, EPs, singles) returned per artist.

## Actor input object example

```json
{
  "artists": [
    "Daft Punk",
    "Radiohead"
  ],
  "includeReleaseGroups": true,
  "maxReleaseGroups": 25
}
```

# 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 = {
    "artists": [
        "Daft Punk",
        "Radiohead"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/musicbrainz-artist-release-lookup").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 = { "artists": [
        "Daft Punk",
        "Radiohead",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/musicbrainz-artist-release-lookup").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 '{
  "artists": [
    "Daft Punk",
    "Radiohead"
  ]
}' |
apify call fit_melon/musicbrainz-artist-release-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/musicbrainz-artist-release-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MusicBrainz Artist & Release Lookup (Free)",
        "description": "Bulk artist and discography lookup from MusicBrainz, the open music encyclopedia. Get MBID, country, genres/tags, life span and all release groups (albums, EPs, singles) as clean JSON. Free music data enrichment.",
        "version": "0.0",
        "x-build-id": "692IYqLANuuWaTOOw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~musicbrainz-artist-release-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-musicbrainz-artist-release-lookup",
                "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/fit_melon~musicbrainz-artist-release-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-musicbrainz-artist-release-lookup",
                "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/fit_melon~musicbrainz-artist-release-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-musicbrainz-artist-release-lookup",
                "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": [
                    "artists"
                ],
                "properties": {
                    "artists": {
                        "title": "Artist names",
                        "type": "array",
                        "description": "List of artist or band names to look up on MusicBrainz. One dataset item is produced per name. Example: Daft Punk, Radiohead, Miles Davis.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReleaseGroups": {
                        "title": "Include discography (release groups)",
                        "type": "boolean",
                        "description": "If enabled, fetches the artist's albums, EPs and singles (release groups) sorted by first release date. Adds one extra request per artist.",
                        "default": true
                    },
                    "maxReleaseGroups": {
                        "title": "Max release groups per artist",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of release groups (albums, EPs, singles) returned per artist.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
