# Discogs Music Scraper — Releases, Prices, Artists & Labels (`haketa/discogs-scraper`) Actor

Scrape Discogs music data: releases, masters, artists and labels with title, artist, year, country, genre, style, format, label, catalog number, barcode, community have/want and marketplace price (lowest price, copies for sale). For collectors, resellers and music research.

- **URL**: https://apify.com/haketa/discogs-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Discogs Music Scraper — Releases, Marketplace Prices, Vinyl Resale & Tracklists

> **The premier Discogs scraper to search, track, and extract exhaustive music discography and marketplace intelligence at scale.** Extract granular records for commercial releases, vinyl pressings, master albums, artists, and record labels. Captures official catalog numbers, barcodes, release years, countries of origin, genre and style tags, complete tracklists with durations, high-resolution cover artwork, community collection/wantlist metrics, and live secondhand marketplace pricing (lowest listing price and copies for sale).
>
> Export structured music databases instantly to **JSON, CSV, Excel, XML, or connect via Apify REST API, webhooks, and cloud workflows**.

[![Discogs Scraper](https://img.shields.io/badge/Discogs-Music%20Database-333333?style=for-the-badge\&logo=discogs\&logoColor=white)](https://apify.com/haketa/discogs-scraper)
[![Marketplace Prices](https://img.shields.io/badge/Marketplace%20Prices%20%2B%20Inventory-2da44e?style=for-the-badge)](https://apify.com/haketa/discogs-scraper)
[![Vinyl & CD](https://img.shields.io/badge/Vinyl%20%2B%20CD%20%2B%20Cassette-ff6b00?style=for-the-badge)](https://apify.com/haketa/discogs-scraper)
[![Tracklists](https://img.shields.io/badge/Tracklists%20%2B%20Artwork-8250df?style=for-the-badge)](https://apify.com/haketa/discogs-scraper)
[![Export](https://img.shields.io/badge/Export-JSON%20%2F%20CSV%20%2F%20Excel-0077b6?style=for-the-badge)](https://apify.com/haketa/discogs-scraper)

***

### ⚡ At a glance

| Feature | Specification | Description |
|---|---|---|
| **Coverage Scope** | 17M+ Releases, 9M+ Artists, 2M+ Labels | The world's largest crowd-sourced physical music catalog |
| **Supported Entities** | Releases (Pressings), Masters (Albums), Artists, Labels | Full structural hierarchy spanning physical and digital music |
| **Pricing Intelligence** | Lowest Current Price, Copies for Sale | Real-time secondhand marketplace valuations and inventory supply |
| **Collector Metrics** | Community Have, Community Want, Rating | Demand vs. supply ratio indicators to detect scarce collector grails |
| **Physical Descriptors** | Format (Vinyl, CD, Cassette), Catalog No, Barcode | Precise pressing identifiers for inventory cataloging and trade-ins |
| **Media Enrichment** | Tracklists, Song Titles, High-Res Cover Images | Complete album track sequencing, durations, notes, and cover art |
| **Deep Pagination** | Unlocked 1,000+ Records per Search | Automatic multi-page traversal (100 records per page batch) |
| **Speed & Performance** | Pure HTTP Datacenter Execution | Concurrent detail fetching for rapid execution without browser bloat |
| **Export Formats** | JSON, CSV, Excel, XML, HTML, REST API | Ready for Shopify, WooCommerce, Airtable, and custom inventory databases |

***

### 🔎 Why scrape Discogs?

Discogs stands as the definitive global clearinghouse for physical music data and secondhand record valuations. For record store owners, independent record labels, crate-diggers, vinyl resellers, and musicologists, Discogs provides irreplaceable data points: historical pressing variations, regional matrix runout identifiers, original release dates, and up-to-the-minute secondhand marketplace pricing.

Manually looking up hundreds of vinyl records or CD variants is laborious. Browser interfaces require navigating individual release pages to inspect tracklists, notes, and marketplace prices. Building automated pricing feeds or bulk cataloging an acquired estate collection demands structured, automated extraction.

This **Discogs scraper** automates this workflow end-to-end. It queries search terms, traverses pagination pages automatically, merges detailed pressing metadata with live marketplace pricing, eliminates duplicate pressings, and outputs structured datasets ready for instant operational use.

#### High-Impact Strategic Applications

- **Automated Record Store Inventory Valuation:** Bulk price newly acquired vinyl collections by cross-referencing catalog numbers against lowest active marketplace prices and available supply.
- **Arbitrage & Rare Vinyl Flipping:** Detect undervalued listings by comparing `communityWant` against `numForSale` to identify high-demand, low-supply physical grails.
- **E-Commerce Catalog Enrichment:** Backfill missing barcodes, catalog numbers, genre/style tags, tracklists, and cover art into Shopify, Discogs seller accounts, or POS systems.
- **Label & A\&R Catalog Research:** Analyze historical back-catalogs, reissue frequencies, and community ratings across iconic independent and major record labels.
- **Musicological & Academic Research:** Map the evolution of micro-genres, electronic music sub-styles, regional pressing distribution, and format transitions across decades.
- **Historical Price Trend Tracking:** Schedule automated recurring jobs to build historical price-action charts for legendary first pressings.

***

### ✨ Key Features & Capabilities

- ✅ **Four Search Entity Modes:** Extract **Releases** (specific pressings), **Masters** (top-level master albums), **Artists** (biographies, members), or **Labels** (catalog rosters).
- ✅ **Real-Time Marketplace Pricing:** Automatically retrieves the **lowest available price** and total **copies for sale** across the global marketplace (`includePricing`).
- ✅ **Deep Multi-Page Pagination:** Automatically paginates through 100 results per page, enabling seamless extraction of hundreds or thousands of records per query.
- ✅ **Community Demand Indicators:** Measures exact **communityHave**, **communityWant**, and **communityRating** metrics to gauge collector desirability.
- ✅ **Granular Physical Identifiers:** Captures exact **catalog numbers**, **barcodes**, matrix identifiers, release year, country of pressing, and packaging formats.
- ✅ **Full Tracklists & Album Credits:** Pulls ordered tracklist song titles, track counts, release notes, and album credits for every release.
- ✅ **Cover Artwork & Thumbnails:** Extracts direct URLs for primary cover art and thumbnail images suitable for e-commerce galleries.
- ✅ **Advanced Facet Filtering:** Filter searches on the fly by `genre`, `style`, `year`, `country`, and `format` to pinpoint exact pressings.

***

### 💼 Industry Use Case Playbooks

#### 1. Independent Record Store Collection Intake

When purchasing a private collection of 500 vinyl records, manually appraising each album takes days. Staff can enter the catalog numbers or album titles into the scraper, download the CSV, and immediately review the lowest marketplace price, current copies for sale, and collector demand metrics (`communityWant`). Pricing inventory becomes an automated 10-minute task.

#### 2. Vinyl Reseller Arbitrage & Grail Sourcing

Online resellers operating on eBay, Whatnot, and Discogs can track high-yield vinyl releases. By filtering for specific niche styles (e.g. `Japanese City Pop`, `UK Drill`, `90s Shoegaze`) and comparing want-to-have ratios where `communityWant` exceeds `communityHave` by 5:1, flippers can pinpoint high-velocity inventory to source at record fairs.

#### 3. Record Label Reissue Due Diligence

A\&R executives investigating catalog reissue opportunities can benchmark an artist's out-of-print discography. Analyzing marketplace prices for original 1970s pressings and tracking the number of users waiting on wantlists helps determine commercial viability for high-end vinyl remasters and deluxe box sets.

#### 4. Digital Music Archiving & Discography Cleaning

Radio stations, streaming curators, and digital archivists can enrich metadata archives with canonical Discogs information. Standardize album release years, country classifications, and sub-genre style tags with 100% catalog consistency.

***

### 📥 Input Parameters

All parameters are optional. Running the actor with empty input performs a demonstration search across landmark rock and electronic albums.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | Array of Strings | `["radiohead"]` | Artists, album titles, record labels, or catalog numbers to search and paginate across. |
| `type` | String (Select) | `"release"` | Search entity type: `release` (specific pressing), `master` (album), `artist`, or `label`. |
| `genre` | String | `""` | Optional high-level genre filter (e.g. `Rock`, `Jazz`, `Electronic`, `Funk / Soul`). |
| `style` | String | `""` | Optional sub-genre style filter (e.g. `House`, `Bebop`, `Shoegaze`, `Synth-pop`). |
| `year` | String | `""` | Optional 4-digit release year filter (e.g. `1997`). |
| `country` | String | `""` | Optional country of release filter (e.g. `UK`, `US`, `Japan`, `Germany`). |
| `format` | String | `""` | Optional physical format filter (e.g. `Vinyl`, `LP`, `CD`, `Cassette`, `Box Set`). |
| `includePricing` | Boolean | `true` | Fetch lowest marketplace price, copies for sale, tracklist, and cover artwork. |
| `token` | String | `""` | Optional personal user token to elevate rate limits during massive continuous runs. |
| `maxItems` | Integer | `0` | Maximum total records across all searches. `0` = unlimited (governed by available pages). |
| `maxPagesPerSearch` | Integer | `0` | Maximum result pages per search term (100 records/page). `0` = auto/unlimited. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Apify Proxy configuration. Standard datacenter proxies provide optimal performance. |

#### Sample JSON Configuration: Rare Vinyl Sourcing

```json
{
  "searchTerms": ["Miles Davis", "John Coltrane"],
  "type": "release",
  "genre": "Jazz",
  "format": "Vinyl",
  "includePricing": true,
  "maxItems": 250,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

***

### 📊 Extracted Data Structure

#### 🎵 Release & Master Record Schema

| Field | Description | Type | Coverage |
|---|---|---|---|
| `id` | Unique numerical Discogs database record identifier | Number | 🟢 High (100%) |
| `type` | Entity type classification (`release`, `master`, `artist`, `label`) | String | 🟢 High (100%) |
| `title` | Full release title (Artist - Album Title) | String | 🟢 High (100%) |
| `artists` | Array of parsed contributing artist display names | Array | 🟢 High (~98%) |
| `year` | 4-digit year of release | String | 🟢 High (~90%) |
| `releasedDate` | Exact historical release date (YYYY-MM-DD or partial) | String | 🟡 Conditional (~70%) |
| `country` | Geographic country of manufacture or distribution | String | 🟢 High (~90%) |
| `genres` | Primary genre classifications (e.g., `Electronic`, `Rock`) | Array | 🟢 High (100%) |
| `styles` | Micro-genre sub-style descriptors (e.g., `IDM`, `Ambient`) | Array | 🟢 High (~90%) |
| `formats` | Physical medium descriptors (e.g., `Vinyl`, `LP`, `180g`, `Stereo`) | Array | 🟢 High (~98%) |
| `labels` | Record label imprint names | Array | 🟢 High (~95%) |
| `catalogNumber` | Official label catalog identification number | String | 🟢 High (~90%) |
| `barcode` | Array of scanned commercial barcodes and matrix runout codes | Array | 🟢 High (~80%) |
| `lowestPrice` | Lowest active secondhand marketplace price in local currency | Number | 🟡 Conditional (~65%) |
| `numForSale` | Total count of physical copies currently listed for sale | Number | 🟢 High (100%) |
| `communityHave` | Total count of registered collectors who own this pressing | Number | 🟢 High (100%) |
| `communityWant` | Total count of registered collectors seeking this pressing | Number | 🟢 High (100%) |
| `communityRating` | Average user community rating score (out of 5.0) | Number | 🟢 High (~90%) |
| `trackCount` | Total number of audio tracks on the release | Number | 🟢 High (~95%) |
| `tracks` | Ordered list of audio track titles (up to 50 tracks) | Array | 🟢 High (~95%) |
| `notes` | Archival release notes, mastering credits, and pressing details | String | 🟡 Conditional (~50%) |
| `thumb` | 150px thumbnail image URL | String | 🟢 High (~90%) |
| `coverImage` | High-resolution primary cover artwork image URL | String | 🟢 High (~90%) |
| `url` | Direct public Discogs web page link | String | 🟢 High (100%) |
| `scrapedAt` | ISO 8601 data extraction timestamp | String | 🟢 High (100%) |

#### 🎤 Artist & Label Record Schema

| Field | Description | Type | Coverage |
|---|---|---|---|
| `profile` | Detailed historical biography or label profile summary | String | 🟢 High (~85%) |
| `members` | Band or group member roster names | Array | 🟡 Conditional (~60%) |
| `externalUrls` | Official social media, Bandcamp, and website URLs | Array | 🟢 High (~80%) |
| `contactInfo` | Official mailing address or business email for labels | String | 🟡 Conditional (~30%) |
| `realName` | Legal birth name for individual solo artists | String | 🟡 Conditional (~50%) |

***

### 💻 Sample Output Record: Vinyl Pressing

```json
{
  "id": 7426074,
  "type": "release",
  "title": "Miles Davis - Miles Davis At Fillmore",
  "artists": ["Miles Davis"],
  "year": "1970",
  "releasedDate": "1970-10-28",
  "country": "US",
  "genres": ["Electronic", "Jazz"],
  "styles": ["Free Jazz", "Fusion", "Experimental"],
  "formats": ["Vinyl", "LP", "Album", "Stereo"],
  "labels": ["Columbia", "Columbia Records", "CBS Inc."],
  "catalogNumber": "G 30038",
  "barcode": ["C 30241", "C 30242", "AL 30241"],
  "masterId": 65664,
  "lowestPrice": 15.0,
  "numForSale": 53,
  "communityHave": 3079,
  "communityWant": 508,
  "communityRating": 4.15,
  "trackCount": 4,
  "tracks": [
    "Wednesday Miles",
    "Thursday Miles",
    "Friday Miles",
    "Saturday Miles"
  ],
  "notes": "Recorded live at the Fillmore East, N.Y. Gatefold jacket.",
  "thumb": "https://i.discogs.com/example/R-7426074-thumb.jpeg",
  "coverImage": "https://i.discogs.com/example/R-7426074-cover.jpeg",
  "url": "https://www.discogs.com/release/7426074-Miles-Davis-Miles-Davis-At-Fillmore",
  "resourceUrl": "https://api.discogs.com/releases/7426074",
  "scrapedAt": "2026-11-10T14:40:00.000Z"
}
```

***

### 🛠️ Step-by-Step Practical Integration Guide

#### 1. Interactive Console Execution

1. Open the actor in the **Apify Console**.
2. Enter artist names, album titles, or catalog codes in `searchTerms`.
3. Choose the target entity `type` (`release`, `master`, `artist`, or `label`).
4. Keep `includePricing: true` to capture live marketplace valuations and tracklists.
5. Set `maxItems` to your target volume and click **Start**.

#### 2. Python Inventory Appraisal Pipeline

```python
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

## Search and price classic Blue Note jazz vinyl pressings
run = client.actor("haketa/discogs-scraper").call(run_input={
    "searchTerms": ["Blue Note"],
    "type": "release",
    "genre": "Jazz",
    "format": "Vinyl",
    "includePricing": True,
    "maxItems": 150,
    "maxPagesPerSearch": 0
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame(items)

## Identify scarce high-value pressings
valuable = df[df["lowestPrice"] > 50][["title", "year", "lowestPrice", "numForSale", "communityWant"]]
print(valuable.sort_values(by="lowestPrice", ascending=False).head(10))
```

#### 3. Node.js & TypeScript Pipeline

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/discogs-scraper').call({
    searchTerms: ['Aphex Twin', 'Boards of Canada'],
    type: 'release',
    format: 'Vinyl',
    includePricing: true,
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`${item.title} | Low Price: $${item.lowestPrice} | Copies: ${item.numForSale}`);
}
```

#### 4. cURL & REST API Direct Query

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~discogs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["OK Computer"],
    "type": "release",
    "format": "Vinyl",
    "includePricing": true,
    "maxItems": 50,
    "maxPagesPerSearch": 0
  }'
```

***

### ⚖️ Manual Digging vs. Automated Discogs Scraping

| Evaluation Dimension | Manual Discogs Search | Discogs Music Scraper |
|---|---|---|
| **Extraction Throughput** | ~15 pressings / hour | ~500+ pressings / minute |
| **Marketplace Valuations** | Inspect each individual listing | Structured `lowestPrice` and `numForSale` columns |
| **Scarcity Comparison** | Calculate want/have mentally | Filter programmatically where `want > have * 3` |
| **Tracklist Ingestion** | Retype song titles manually | Structured array of tracks ready for audio databases |
| **Batch Querying** | Single query at a time | Multi-term batch queries with auto de-duplication |
| **Data Export** | Copy-paste to spreadsheet | Instant JSON, CSV, Excel, XML, and Webhooks |

***

### 📈 Collector Scarcity & Demand Index Calculation

A key superpower of this actor is enabling programmatic valuation formulas based on the Discogs community demand ratio:

| Scarcity Tier | Want / Have Ratio | Market Characteristic | Resale Strategy |
|---|---|---|---|
| **Ultra-Rare Grail** | Ratio > 5.0 (e.g. Want: 5,000 / Have: 800) | Extreme collector deficit | Premium pricing; immediate acquisition target |
| **High Velocity** | Ratio between 2.0 and 5.0 | Steady demand, liquid turnover | Competitive marketplace pricing; fast sale |
| **Balanced Evergreen** | Ratio between 0.8 and 2.0 | Stable catalog title | Standard market catalog staple |
| **Oversupplied Bargain** | Ratio < 0.5 (e.g. Want: 100 / Have: 1,500) | Heavy market saturation | Deep discount / bargain bin inventory |

By calculating `communityWant / (communityHave + 1)` in post-processing, automated reseller pipelines can dynamically classify newly scraped inventory into actionable buying tiers.

***

### 💡 Best Practices for High-Yield Music Extraction

- **Keep Details & Pricing Enabled:** Leaving `includePricing: true` triggers secondary detail queries that enrich each release with lowest price, number of copies for sale, full tracklists, community rating, notes, and cover images.
- **Isolate First Pressings:** Use the `year` and `country` filter parameters (e.g. `year: "1973"`, `country: "UK"`) to isolate original first pressings from modern 180g reissues.
- **Search by Catalog Number:** For maximum cataloging accuracy, enter exact catalog numbers (e.g. `BST 84154` or `WARP LP 66`) into `searchTerms`.
- **Handling Missing Prices:** If `lowestPrice` is empty, it signifies zero copies are currently listed for sale in the marketplace, which often indicates extreme rarity. Check `communityHave` and `communityWant` to evaluate real-world scarcity.

***

### ❓ Frequently Asked Questions

**Does this actor require a Discogs user account or token?**
No. The scraper runs keyless out of the box. An optional `token` field is provided if you wish to link your personal token for massive extended workloads.

**How does deep pagination work?**
The scraper retrieves 100 records per page batch. Setting `maxPagesPerSearch: 0` traverses consecutive pagination pages until reaching your requested `maxItems` limit or exhausting all results.

**Can I look up artists and record labels?**
Yes. Switch the `type` selector to `artist` or `label`. The scraper returns artist biographies, group members, label rosters, and external URLs.

**What proxies are recommended for scraping Discogs?**
Standard Apify Datacenter proxies are enabled by default and dynamically rotate across requests, ensuring smooth and resilient performance.

**What formats can I export data into?**
You can export results in JSON, CSV, Excel, XML, or connect directly via webhooks, Google Sheets, Make, Zapier, and Apify REST APIs.

**Can I look up specific vinyl pressings by barcode?**
Yes. You can paste 12-digit UPC or 13-digit EAN barcodes directly into `searchTerms`. The scraper will return matching physical releases.

**How does the scraper handle multi-disc box sets?**
For box sets containing multiple vinyl records or CDs, the scraper captures total track counts across all discs and stores the individual track titles sequentially in the `tracks` array.

**Can I scrape international pressing variations?**
Yes. Use the `country` parameter (e.g., `Japan`, `Germany`, `UK`, `France`, `US`) to filter releases pressed in specific manufacturing plants, which is vital for Japanese OBI strip pressings or German audiophile vinyl.

**How fresh is marketplace pricing?**
Pricing is retrieved live at execution time directly from active marketplace listings, giving you the real-time lowest price and inventory counts.

**Can I run automated weekly price monitors?**
Yes. You can schedule the actor to run weekly on your personal wantlist or target high-value releases, piping newly found low prices or fresh listings straight to Slack, Discord, or an email digest.

**Is there any risk of IP blocks?**
No. The actor routes traffic through Apify's rotating datacenter proxies, ensuring continuous compliance with rate limits and preventing request failures.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Unlocked 1,000+ Deep Pagination:** Removed restrictive default page limits; setting `maxPagesPerSearch: 0` now enables automatic infinite pagination governed strictly by user-defined item limits.
- **Enhanced Empty Input Fallbacks:** Integrated iconic landmark album default queries ensuring zero-configuration runs return rich multi-genre music datasets without early termination.
- **Accelerated Detail Concurrency:** Streamlined parallel detail fetching for tracklists and marketplace pricing, cutting run duration significantly.
- **Optimized Cover Artwork Resolution:** Upgraded primary image resolution selection for release and master profiles.

#### Version 1.1 (2026-10)

- Added marketplace pricing fields (`lowestPrice`, `numForSale`).
- Added community engagement metrics (`communityHave`, `communityWant`, `communityRating`).
- Integrated complete tracklist and cover image extraction.

#### Version 1.0 (2026-10)

- Initial release featuring multi-entity search across releases, masters, artists, and labels.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/discogs-scraper/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Artists, albums, labels or keywords (e.g. "radiohead", "blue note", "ok computer").

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

What to search for.

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

e.g. Rock, Jazz, Electronic (optional).

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

e.g. House, Bebop, Shoegaze (optional).

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

Release year (optional).

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

Country of release (optional).

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

e.g. Vinyl, CD, Cassette (optional).

## `includePricing` (type: `boolean`):

For releases/masters, fetch lowest marketplace price, copies for sale and tracklist. For artists/labels, fetch profile.

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

Optional free Discogs personal token to raise the rate limit.

## `maxItems` (type: `integer`):

Maximum results across all searches. 0 = no limit.

## `maxPagesPerSearch` (type: `integer`):

Pagination cap per search term (100 per page). 0 = auto / unlimited (governed by max results).

## `proxyConfiguration` (type: `object`):

Apify Proxy. Datacenter is enough; rotating IPs each get their own Discogs rate-limit budget.

## Actor input object example

```json
{
  "searchTerms": [
    "radiohead"
  ],
  "type": "release",
  "includePricing": true,
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Discogs ID

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

release/artist/label

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

Title / name

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

Artists

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

Year

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

Release date

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

Country

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

Genres

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

Styles

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

Formats

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

Labels

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

Catalog number

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

Barcode

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

Lowest marketplace price

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

Copies for sale

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

Collection count

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

Wantlist count

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

Average rating

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

Track count

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

Track titles

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

Master release ID

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

Artist/label profile

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

Band members

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

External links

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

Thumbnail URL

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

Cover image URL

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

Discogs URL

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

ISO timestamp

# 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 = {
    "searchTerms": [
        "radiohead"
    ],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "searchTerms": ["radiohead"],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "searchTerms": [
    "radiohead"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/discogs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/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/0FSPMzJNohGsqSCRT/builds/BCwHsVmmczRwgcqEd/openapi.json