# 💿 Discogs Scraper - Vinyl, Releases & Labels (`benthepythondev/discogs-scraper`) Actor

Discogs Scraper to search the Discogs music database for vinyl, CDs and releases by artist, album, genre or year. Extract title, year, country, genre, style, format, label, catalog number, barcode and cover image. For record collectors, music data tools and discography databases.

- **URL**: https://apify.com/benthepythondev/discogs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Automation, E-commerce, Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 💿 Discogs Scraper — Vinyl, Music Releases & Labels

Extract music data from **[Discogs](https://www.discogs.com)** — the world's largest catalog of vinyl, CDs and music releases — as clean, structured data. Search the Discogs database by keyword, type, genre or year and get **title, year, country, genre, style, format, label, catalog number, barcode and cover image** for every result. It's keyless, fast and reliable — no proxy or browser needed. Built for record collectors, music data tools and discography databases. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🎵 What is the Discogs Scraper?

It turns any Discogs database search into a structured dataset. Give it a search term (like `daft punk` or `nirvana nevermind`), choose what to search for (release, master, artist or label), and optionally filter by genre and year — it returns every matching result with full metadata and cover art. Because it queries the public Discogs database API and flattens the paged JSON into clean rows, you get tidy, ready-to-use records without touching the raw API. It paginates automatically and respects Discogs' rate limits.

Every result arrives with the fields collectors and music apps actually need: the catalog number and barcode to identify an exact pressing, the country and year to tell editions apart, genre and style arrays for filtering, the format breakdown (Vinyl, LP, CD, Album) and both thumbnail and full-size cover art. Each record also carries its Discogs `id`, the `master_id` that groups all versions of a recording, and direct links to the Discogs page and the API resource — so you can drill deeper whenever you need to. Billing is per result, so empty searches cost nothing.

#### What data does it extract?

- **`title`** and **`id`**
- **`type`** — release / master / artist / label
- **`year`** and **`country`**
- **`genre`** and **`style`**
- **`format`** — Vinyl, LP, CD, Album, …
- **`label`** and **`catno`** (catalog number)
- **`barcode`** and **`master_id`**
- **`thumb`** and **`cover_image`**
- **`url`** and **`resource_url`**
- **`search_query`** and **`scraped_at`**

### ⬇️ Input

Search the Discogs database by keyword, with optional filters:

| Field | Description |
|-------|-------------|
| `searchQuery` | Artist, album or release keyword, e.g. `daft punk`, `nirvana nevermind` |
| `type` | What to search for — `release`, `master`, `artist` or `label` |
| `genre` | Optional genre filter, e.g. `Electronic`, `Rock`, `Jazz` |
| `year` | Optional release year filter, e.g. `1997` |
| `maxResults` | Maximum results to return (1–10000) |

#### Example input

```json
{
  "searchQuery": "daft punk",
  "type": "release",
  "genre": "Electronic",
  "year": "2001",
  "maxResults": 50
}
```

### ⬆️ Output

Every result is one clean row (view as a **table**, or export **JSON / CSV / Excel**):

```json
{
  "id": 7445961,
  "type": "release",
  "title": "Daft Punk - Discovery",
  "year": "2001",
  "country": "Europe",
  "genre": ["Electronic"],
  "style": ["House", "Disco"],
  "format": ["Vinyl", "LP", "Album"],
  "label": ["Virgin"],
  "catno": "7243 8 49606 1 1",
  "barcode": ["724384960612"],
  "master_id": 23838,
  "thumb": "https://i.discogs.com/.../R-150.jpg",
  "cover_image": "https://i.discogs.com/.../R.jpg",
  "url": "https://www.discogs.com/release/7445961",
  "resource_url": "https://api.discogs.com/releases/7445961",
  "search_query": "daft punk",
  "scraped_at": "2026-06-26T15:30:00+00:00"
}
```

### 💡 Use cases

- **🎶 Record collecting:** track pressings, variants, catalog numbers and barcodes for any artist or album.
- **📊 Marketplace analytics:** analyse releases by genre, year, country and format to spot trends.
- **🗂️ Music databases:** build and enrich discographies with clean, structured metadata.
- **🖼️ Data enrichment:** append release details and cover art to your own catalog or app.

### ❓ FAQ

**How do I search the Discogs database?** Enter a `searchQuery`, choose a `type` (release, master, artist or label), optionally add a `genre` and `year`, then Run. You get structured results with title, year, country, genre, format, label, catalog number and cover art.

**What's the difference between a release and a master?** A release is one specific pressing/version, while a master groups all versions of the same recording. Set `type` to `master` to dedupe across pressings, or `release` for every individual edition.

**Can I search by genre or year only?** You can combine a keyword with genre and year filters. A `searchQuery` (or genre) is required to run — keyword plus `genre` and `year` together gives the most precise results.

**Do I need an API key?** No. It's keyless — just enter a search query. There's no Discogs account or token to set up.

**Do I need a proxy?** No. It calls the public Discogs database API directly, so no proxy or browser is required.

**Does it include cover art?** Yes — each result includes both a `thumb` (small) and `cover_image` (full-size) URL where available.

**How many results can it return?** Up to your `maxResults` cap (max 10000); it paginates the API automatically and waits between pages to respect Discogs' rate limit (~25 requests/min).

**Can I get artists and labels too?** Yes — set `type` to `artist` or `label` to search those instead of releases.

**Can I run it on a schedule or via API?** Yes — schedule recurring runs in Apify, call it via the API/SDK, or connect it to Make, Zapier or n8n.

**How do I identify a specific pressing?** Use the `catno` (catalog number), `barcode`, `country` and `year` fields together — they pin down an exact edition, while `master_id` links it back to all other versions of the same recording.

**Is scraping Discogs legal?** It uses the public Discogs database API to retrieve publicly available metadata. Use the data only for lawful purposes and respect Discogs' terms and rate limits.

### 🔗 You might also like

- **[iTunes Scraper](https://apify.com/benthepythondev/itunes-scraper)** — music, podcasts, apps & more from Apple
- **[Steam Scraper](https://apify.com/benthepythondev/steam-scraper)** — game prices, ratings & store data
- **[eBay Scraper](https://apify.com/benthepythondev/ebay-scraper)** — listings, prices & seller data via the official API

***

**Keywords:** Discogs scraper, Discogs API, vinyl data, music database, record collecting, discography data, music releases scraper, catalog number lookup, barcode music data, genre style metadata, record label data, vinyl cover art, music marketplace analytics, Discogs database search.

# Actor input Schema

## `searchQuery` (type: `string`):

Artist, album or release keyword (e.g. 'daft punk', 'nirvana nevermind').

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

What to search for.

## `genre` (type: `string`):

Filter by genre (e.g. 'Electronic', 'Rock', 'Jazz').

## `year` (type: `string`):

Filter by release year (e.g. '1997').

## `maxResults` (type: `integer`):

Maximum number of results to return.

## Actor input object example

```json
{
  "searchQuery": "daft punk",
  "type": "release",
  "genre": "",
  "year": "",
  "maxResults": 25
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "daft punk",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/discogs-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 = {
    "searchQuery": "daft punk",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/discogs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "daft punk",
  "maxResults": 25
}' |
apify call benthepythondev/discogs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,benthepythondev/discogs-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/h04Bx2zxWAMDPS4HJ/builds/nSHyuycNDkU6jcOyW/openapi.json