# Discogs Scraper — Vinyl, Music Releases, Artists & Labels (`logiover/discogs-scraper`) Actor
Unofficial Discogs API — no key, no browser. Scrape music releases, vinyl records, masters, artists & labels: full discographies, label catalogs, every pressing/version, genres, styles, formats, catalog numbers and marketplace stats. Export Discogs data to JSON, CSV or Excel.
- **URL**: https://apify.com/logiover/discogs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 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 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 Records, Music Releases, Artists & Labels Data (No API Key)
    
Scrape the **Discogs** music database — the world's largest catalog of **vinyl records, CDs and music releases** — in one Apify Actor. Pull an **artist's full discography**, a **record label's entire catalog**, **every pressing/version of an album**, free-text **search** results, and complete **release / master / artist / label** details, straight from the **public Discogs API**. Get **titles, artists, years, genres, styles, formats, catalog numbers, barcodes, cover art, community have/want counts and marketplace prices** in clean, flat JSON. **Fast HTTP, no browser, no API key, no login.**
> ### 🏆 Why this Discogs scraper?
>
> **8 modes in one input form** · **hundreds–thousands of rows per run** · direct HTTP + JSON (no headless browser) · flat, CSV-ready output · 4 pre-built dataset views · every row tagged with `_mode` so you can mix modes in one dataset. The unofficial **Discogs API alternative** for record collectors, vinyl resellers, catalog enrichment and music-data teams — no OAuth token to manage.
***
### ✨ What this Actor does / Key features
- 💿 **8 endpoints, one form** — artist discography, label catalog, master versions/pressings, free-text search, plus release / master / artist / label detail lookups (single or batch).
- 🎸 **Full discographies** — an artist's entire release + master list, paginated through the whole catalog (hundreds or thousands of rows).
- 🏷️ **Label catalogs** — a record label's complete back catalog with catalog numbers, formats and release years.
- 📀 **Every pressing / version** — all reissues and repressings of an album (the "master"), each with country, format, label and catalog number — ideal for vinyl variant research.
- 🔎 **Keyless search** — free-text search across releases, masters, artists and labels, returning genres, styles, formats, catalog numbers and barcodes.
- ⭐ **Marketplace & demand signals** — community `have` / `want` counts, `ratingAverage`, `lowestPrice` and `numForSale` without scraping listing pages.
- 🖼️ **Cover art & links** — `thumb` / `coverImage` plus a ready-to-open `discogsUrl` and raw `resourceUrl` on every item.
- ⚡ **Direct HTTP + JSON** — reads the public Discogs API; no browser, no DOM walking, no OAuth token. The Actor sets the required descriptive User-Agent for you.
- 🧩 **Mode-tagged output** — every row carries `_mode` and `scrapedAt` (ISO 8601), so you can mix modes in one run and filter later across 4 dataset views (Overview, Releases, Artists, Labels).
#### The 8 modes
| Mode | What it returns |
|---|---|
| `artistReleases` | An artist's full discography, paginated (highest volume) — **default** |
| `labelReleases` | A record label's complete catalog, paginated |
| `masterVersions` | Every pressing / version of an album (master), paginated |
| `search` | Free-text search across releases, masters, artists and labels |
| `release` | Full details for one or many release IDs (batch) |
| `master` | Full details for one or many master (album) IDs (batch) |
| `artist` | Artist profile details for one or many artist IDs (batch) |
| `label` | Record-label details for one or many label IDs (batch) |
### 🚀 Quick start (3 steps)
1. **Pick a mode** — open the Actor and choose one of the 8 modes. The input form shows which fields that mode needs.
2. **Fill the ID / query** — e.g. an `artistId` for a discography, a `masterId` for versions, or a `query` for search. IDs are just the numbers in a Discogs URL.
3. **Run & export** — click **Start**, then export the dataset to **JSON, CSV, Excel (XLSX), HTML, RSS or JSON Lines**, or pull it via the Apify API.
> **IDs are just the numbers in a Discogs URL.** `discogs.com/artist/108713-Nickelback` → artist `108713` · `discogs.com/master/13814-Nirvana-Nevermind` → master `13814` · `discogs.com/label/1-Planet-E` → label `1` · `discogs.com/release/1018` → release `1018`. Run `search` first to discover IDs, then feed them into the detail or list modes.
### 📥 Input
Pick a `mode`, then fill the fields that mode needs. `mode` is the only required field.
#### Example — an artist's full discography
```json
{
"mode": "artistReleases",
"artistId": "108713",
"sort": "year",
"sortOrder": "desc",
"maxResults": 300
}
```
#### Example — every pressing / version of an album
```json
{
"mode": "masterVersions",
"masterId": "13814",
"maxResults": 500
}
```
#### Example — free-text search across the Discogs database
```json
{
"mode": "search",
"query": "nirvana nevermind",
"searchType": "release",
"maxResults": 100
}
```
| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | Which Discogs endpoint to run: `artistReleases`, `labelReleases`, `masterVersions`, `search`, `release`, `master`, `artist`, `label`. **Required.** |
| `artistId` | string | Artist ID for `artistReleases` / `artist`, e.g. `108713`. |
| `artistIds` | array | Batch of artist IDs for `artist` detail lookups. |
| `labelId` | string | Label ID for `labelReleases` / `label`, e.g. `1` (Planet E). |
| `labelIds` | array | Batch of label IDs for `label` detail lookups. |
| `masterId` | string | Master (album) ID for `masterVersions` / `master`, e.g. `13814`. |
| `masterIds` | array | Batch of master IDs for `master` detail lookups. |
| `releaseId` | string | Release ID for `release`, e.g. `1018`. |
| `releaseIds` | array | Batch of release IDs for `release` detail lookups. |
| `query` | string | Free-text term for `search` (artist, album, label, catalog number, barcode…). |
| `searchType` | string | Restrict `search` to `release`, `master`, `artist` or `label`. Empty = search everything. |
| `sort` | string | Sort field for `artistReleases`: `year`, `title` or `format`. |
| `sortOrder` | string | Sort direction: `asc` or `desc`. |
| `maxResults` | integer | Upper bound on rows. Drives pagination for the list modes; for batch detail modes it is effectively the number of IDs you pass. |
### 📤 Output
One flat row per record — **exportable to JSON, CSV, Excel, HTML, RSS or JSON Lines**. Every row carries a `_mode` tag and a `scrapedAt` timestamp. Here is a trimmed `release`/`artistReleases`-style record:
```json
{
"_mode": "artistReleases",
"id": 367780,
"type": "release",
"title": "Nevermind",
"artist": "Nirvana",
"year": "1991",
"country": "US",
"format": "Vinyl, LP, Album",
"label": "DGC",
"catno": "DGC-24425",
"genres": ["Rock"],
"styles": ["Alternative Rock", "Grunge"],
"have": 41287,
"want": 22930,
"ratingAverage": 4.42,
"lowestPrice": 18.5,
"numForSale": 612,
"thumb": "https://i.discogs.com/…/R-367780.jpeg",
"coverImage": "https://i.discogs.com/…/R-367780.jpeg",
"resourceUrl": "https://api.discogs.com/releases/367780",
"discogsUrl": "https://www.discogs.com/release/367780",
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `_mode` | Which endpoint produced this row (`artistReleases`, `search`, `artist`…) — present on every item |
| `id` | Discogs entity ID (release / master / artist / label) |
| `type` | Entity type (`release`, `master`, `artist`, `label`) |
| `title` | Release / master title |
| `name` | Entity name (artist / label modes) |
| `artist` | Artist / credited name |
| `realName` | Artist's real name (artist mode) |
| `profile` | Artist / label profile text |
| `year` | Release year |
| `country` | Country of release |
| `format` | Format string (e.g. `Vinyl, LP, Album`) |
| `label` | Record label |
| `catno` | Catalog number |
| `genres` | Genre array |
| `styles` | Style array |
| `have` / `want` | Community have / want counts (demand signal) |
| `ratingAverage` | Average community rating |
| `lowestPrice` | Lowest marketplace price |
| `numForSale` | Copies currently for sale |
| `mainRelease` / `numVersions` | Master's main release ID / number of versions (master mode) |
| `aliases` / `members` / `groups` | Artist relationships (artist mode) |
| `contactInfo` / `parentLabel` / `sublabels` | Label metadata (label mode) |
| `urls` | External URLs (artist / label mode) |
| `thumb` / `coverImage` | Thumbnail / cover-art image URL |
| `resourceUrl` | Raw Discogs API resource URL |
| `discogsUrl` | Ready-to-open Discogs page URL |
| `scrapedAt` | Scrape timestamp (ISO 8601) — present on every item |
Fields returned depend on the mode. The 4 dataset views (Overview, Releases, Artists, Labels) surface the relevant columns automatically.
### 💡 Use cases
- **Record collectors** — export an artist's or label's complete discography, track down every vinyl pressing of a favorite album, and build a want-list dataset with `have` / `want` demand signals.
- **Vinyl resellers & price research** — pull `lowestPrice`, `numForSale` and community counts to spot in-demand records, price inventory, and monitor a label's catalog for flips.
- **Catalog enrichment** — enrich your own music or e-commerce catalog with genres, styles, formats, catalog numbers, release years and cover art via the `release` and `master` modes.
- **Music analytics & ML** — bulk-ingest releases, genres, styles and marketplace stats to train recommenders, chart genre trends by decade, or analyze a label's output.
- **AI agents & RAG** — wrap the Actor as a tool so an LLM can answer "list every pressing of Nevermind" or "what has Planet E released?" and embed the structured results.
- **Discography research** — pass an `artistId` batch to build a comparative dataset across multiple artists in a single run.
### 👥 Who uses it
Record collectors & crate diggers · vinyl resellers and marketplace sellers · music-catalog & metadata teams · e-commerce stores enriching product data · music researchers, journalists & ML engineers · AI-agent builders needing structured music data on demand.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay for the records you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
**Can I scrape Discogs without an API key?**
Yes. This is an unofficial Discogs scraper that reads publicly available data through the public Discogs API. You only need an Apify account — no Discogs API key, no OAuth token, no login. (Discogs simply requires a descriptive User-Agent header, which the Actor sets for you.)
**Is this a Discogs API or a Discogs API alternative?**
Both, effectively. It works as an **unofficial Discogs API** and a practical **Discogs data API alternative**: you send structured input and get flat JSON back, with pagination, rate-limit handling and CSV/Excel export handled for you — no token management required.
**Can I scrape Discogs without an API or login?**
Yes. There is no Discogs account, login or OAuth needed — only an Apify account. The Actor pulls publicly available catalog data over direct HTTP.
**How do I export a vinyl collection or discography to CSV or Excel?**
Run `artistReleases`, `labelReleases` or `masterVersions`, then download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSON Lines from the run page, or pull it via the Apify API. This makes it a simple **Discogs data export** and vinyl catalog tool.
**How do I get an artist's full discography data?**
Pick `artistReleases` mode and pass the `artistId` (the number in a `discogs.com/artist/…` URL). The Actor paginates the artist's entire release list — titles, roles, years, formats, catalog numbers and demand stats — up to your `maxResults`.
**How do I get a record label's catalog?**
Use `labelReleases` with the `labelId`. It paginates the label's full catalog with catalog numbers, formats, artists and release years — perfect for label discographies and reissue tracking.
**How do I find every pressing or version of an album?**
Use `masterVersions` with the album's `masterId`. Discogs groups all pressings under a "master"; this mode returns each version with its country, format, label and catalog number — ideal for vinyl variant and reissue research.
**How do I get Discogs marketplace / price data?**
Release and master details include `lowestPrice` and `numForSale`, and most list results include community `have` and `want` counts. Use these to gauge demand and price records without scraping listing pages.
**How much data can I get, and does keyless search work?**
Yes — the public search endpoint returns results without a token. Keyless access is rate-limited to roughly 25 requests per minute, so the Actor spaces requests (~2.5s) and retries with backoff on HTTP 429. Large pulls therefore run slowly by design; the ID-based list modes (`artistReleases`, `labelReleases`, `masterVersions`) are the most efficient way to fetch high volumes — hundreds or thousands of rows per run.
**Is it legal to scrape Discogs?**
The Actor only collects publicly available catalog data through the public Discogs API. You are responsible for using the data in compliance with Discogs' terms and applicable laws.
### 🔗 More music, film & media scrapers by logiover
Building a media or entertainment dataset? Pair Discogs with the rest of the catalog-data suite:
| Actor | What it does |
|---|---|
| [Resident Advisor Scraper](https://apify.com/logiover/resident-advisor-scraper) | Electronic-music events, artists & clubs |
| [Apple Podcasts Episode Scraper](https://apify.com/logiover/apple-podcasts-episode-scraper) | Podcast shows & episode metadata |
| [IMDb Scraper](https://apify.com/logiover/imdb-scraper) | Films, TV titles, cast & ratings |
| [Letterboxd Film Review Scraper](https://apify.com/logiover/letterboxd-film-review-scraper) | Film reviews, ratings & lists |
| [TVmaze Scraper](https://apify.com/logiover/tvmaze-scraper) | TV shows, episodes & schedules |
| [MyAnimeList Anime Scraper](https://apify.com/logiover/mal-anime-scraper) | Anime titles, scores & metadata |
| [Twitch Scraper](https://apify.com/logiover/twitch-scraper) | Streamers, channels & live data |
| [Steam Game Reviews Scraper](https://apify.com/logiover/steam-game-reviews-scraper) | Game reviews & ratings |
| [YouTube Channel Scraper](https://apify.com/logiover/youtube-channel-scraper) | Channel & video metadata |
| [Substack Newsletter Scraper](https://apify.com/logiover/substack-newsletter-scraper) | Newsletter posts & authors |
| [Reddit Subreddit Scraper](https://apify.com/logiover/reddit-subreddit-scraper) | Subreddit posts & discussions |
| [Wikipedia Category Scraper](https://apify.com/logiover/wikipedia-category-scraper) | Category trees & article metadata |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to keep a music catalog or price dataset fresh daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** — or call it from the JavaScript / Python clients or `run-sync-get-dataset-items` — to build automated music-data pipelines.
### ⭐ Support & feedback
Found a bug or need an extra field or mode? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor extracts only publicly available data through the public Discogs API and is intended for legitimate research, cataloging and analytics use. You are responsible for complying with Discogs' terms of service and any applicable local laws.
***
### 📝 Changelog
#### 2026-07-06
- ✨ README overhaul: badge row, ready-to-run example scenarios, trimmed output sample with a full field reference, richer FAQ and a music/media cross-promo grid.
#### 2026-07-01
- Initial release: eight Discogs modes (artist discography, label catalog, master versions/pressings, free-text search, and release / master / artist / label details) over the public Discogs API — no key, no login, no headless browser.
- List modes paginate through the full result set up to `maxResults`; detail modes accept single IDs or batches.
- Respects the keyless ~25 requests/minute rate limit with request spacing and HTTP 429 backoff, and sets the required Discogs User-Agent header on every request.
- Flattened, CSV/Excel-friendly output with four dataset views (Overview, Releases, Artists, Labels) and a `_mode` tag on every row.
# Actor input Schema
## `mode` (type: `string`):
Which Discogs endpoint to run.
• **browse** — most-collected / popular releases, no query needed (used automatically when you run with empty input)
• **artistReleases** — an artist's full discography, paginated (highest volume). With no artist ID it falls back to browse.
• **labelReleases** — a record label's full catalog, paginated (high volume)
• **masterVersions** — every pressing/version of an album, paginated (high volume)
• **search** — free-text search across releases, masters, artists and labels
• **release** — full details for one or more release IDs (batch)
• **master** — full details for one or more master (album) IDs (batch)
• **artist** — profile details for one or more artist IDs (batch)
• **label** — details for one or more label IDs (batch)
## `artistId` (type: `string`):
Discogs artist ID for **artistReleases** and **artist** modes, e.g. `108713`. The number in a `discogs.com/artist/108713-…` URL.
## `artistIds` (type: `array`):
Array of Discogs artist IDs for batch **artist** detail lookups.
## `labelId` (type: `string`):
Discogs label ID for **labelReleases** and **label** modes, e.g. `1` (Planet E). The number in a `discogs.com/label/1-…` URL.
## `labelIds` (type: `array`):
Array of Discogs label IDs for batch **label** detail lookups.
## `masterId` (type: `string`):
Discogs master (album) ID for **masterVersions** and **master** modes, e.g. `13814` (Nirvana — Nevermind). The number in a `discogs.com/master/13814-…` URL.
## `masterIds` (type: `array`):
Array of Discogs master IDs for batch **master** detail lookups.
## `releaseId` (type: `string`):
Discogs release ID for **release** mode, e.g. `1018`. The number in a `discogs.com/release/1018-…` URL.
## `releaseIds` (type: `array`):
Array of Discogs release IDs for batch **release** detail lookups.
## `query` (type: `string`):
Free-text term for **search** mode (artist name, album, label, catalog number, barcode, etc.).
## `searchType` (type: `string`):
Restrict **search** results to one entity type. Leave empty to search everything.
## `sort` (type: `string`):
Sort field. For **browse**: `have` (most-collected), `want` (most-wanted), `year`, `title`, `format`, `catno`, `country`. For **artistReleases**: `year`, `title`, `format`. Defaults to `have` for browse, Discogs default order for artistReleases.
## `sortOrder` (type: `string`):
Sort direction for the `sort` field (browse / artistReleases).
## `maxResults` (type: `integer`):
Upper bound on rows returned. For the list modes (artistReleases / labelReleases / masterVersions / search) this drives pagination; for batch detail modes it is effectively the number of IDs you pass.
## Actor input object example
```json
{
"mode": "artistReleases",
"artistId": "108713",
"artistIds": [],
"labelId": "1",
"labelIds": [],
"masterId": "13814",
"masterIds": [],
"releaseId": "1018",
"releaseIds": [],
"query": "nirvana nevermind",
"sortOrder": "desc",
"maxResults": 150
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset. Use the Releases view for release/version/search lists, and the Artists / Labels views for entity lookups.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "artistReleases",
"artistId": "108713",
"maxResults": 150
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "artistReleases",
"artistId": "108713",
"maxResults": 150,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/discogs-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 '{
"mode": "artistReleases",
"artistId": "108713",
"maxResults": 150
}' |
apify call logiover/discogs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/discogs-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/acts/Lf2DL2Rbvxn0MyENx/builds/n0sCNJfpYRt4XayUJ/openapi.json