# Discogs Scraper - Records, Prices, Artists & Seller Leads (`scrapesage/discogs-scraper`) Actor

Scrape Discogs: vinyl, CD & cassette releases with lowest marketplace price, number for sale, community have/want demand, ratings, tracklists, artists, labels & marketplace seller leads. Search by artist, label, genre, format or barcode, monitor new releases & prices.

- **URL**: https://apify.com/scrapesage/discogs-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 release records

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, CD & Music Marketplace Records, Prices, Demand & Seller Leads

Extract **complete Discogs data** from the world's largest music database and marketplace — **releases and pressings with real marketplace prices, number for sale, community have/want demand, ratings, tracklists, artists, labels** — plus turn marketplace sellers into **B2B record-dealer leads** with location, inventory size, rating, website and a 0–100 lead score.

No login required, no browser — fast JSON extraction straight from the official Discogs API, with 99%+ reliability.

### Why this Discogs scraper?

Discogs is the definitive catalog for vinyl, CDs and cassettes — and a huge collector marketplace. Most scrapers return only thin search results. This actor pulls the **full record** for every release and ships the **richest dataset in the category**:

| Data | Thin scrapers | This actor |
|---|---|---|
| Title, artist, label, catalog #, year, country | ✅ | ✅ |
| Genres, styles, formats (LP / 7" / CD / etc.) | partial | ✅ |
| **Lowest marketplace price + number for sale** | ❌ | ✅ |
| **Community have / want demand + want-to-have ratio** | ❌ | ✅ |
| **Community rating (average + count)** | ❌ | ✅ |
| Full tracklist, images, videos | ❌ | ✅ opt-in |
| Artist profile, members, website & socials | ❌ | ✅ |
| Label profile, sublabels, contact info, socials | ❌ | ✅ |
| **Marketplace seller leads** (location, inventory, rating, website) | ❌ | ✅ |
| Lead score (0–100) per seller | ❌ | ✅ |
| Monitor mode (only new records) | ❌ | ✅ |

### Use cases

- **Price & valuation intelligence** — track the **lowest price** and **number for sale** for any release, and gauge demand with **have/want** counts. Perfect for collectors, dealers, and collection-value tracking.
- **Record-dealer lead generation** — turn marketplace sellers into B2B leads: location, inventory size, seller rating, and their **store website** (then enrich for email with the [Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)).
- **Music catalog & metadata enrichment** — pull clean, structured discographies, labels, formats, genres and styles to power apps, databases, and recommendation engines.
- **Market research** — size demand for a genre, artist, label, or era; find the most-wanted and rarest pressings.
- **Reissue & sourcing decisions** — labels and sellers can spot high want-to-have ratios (under-supplied, in-demand titles) worth repressing or stocking.
- **Monitoring** — schedule recurring runs to catch **new releases** for an artist/label, **new pressings**, or **newly listed items** the moment they appear.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Discogs Scraper**, enter search keywords (e.g. `Daft Punk Discovery`) and optional filters (genre, format, year), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchTerms": ["Aphex Twin"],
    "searchType": "release",
    "genre": "Electronic",
    "format": "Vinyl",
    "includeReleaseDetails": true,
    "currency": "USD",
    "maxResults": 100
}
```

- **searchTerms** — albums, artists, labels, catalog numbers or barcodes. Combined with the filters.
- **searchType** — `release` (a pressing, with price/demand), `master` (an album across versions), `artist`, `label`, or `all`.
- **genre / style / year / country / format / label / artist** — database filters; combine freely (work with no keyword too).
- **startUrls / releaseIds / artistIds / labelIds** — scrape specific Discogs URLs or IDs directly.
- **sellerUsernames** — turn marketplace sellers into record-dealer leads.
- **includeReleaseDetails** *(default true)* — full record: lowest price, number for sale, have/want, rating, tracklist count, images, videos.
- **includeTracklist / includeVideos / includeNotes** — add full tracklist, videos, and notes.
- **includeArtistDiscography** — add release count + top releases (artists) or catalog size (labels).
- **includeSellerInventory** — add a sample of each seller's for-sale listings (item, condition, price).
- **currency** — marketplace price currency (USD, EUR, GBP, JPY, …).
- **monitorMode** *(default false)* — emit only records not seen in previous runs (named store via `monitorKey`).
- **discogsToken** *(optional)* — a free Discogs personal token raises the rate limit 25→60/min.

### Output

One record per item. A **release** record (`type: "release"`):

```json
{
    "type": "release",
    "releaseId": 249504,
    "title": "Never Gonna Give You Up",
    "artist": "Rick Astley",
    "labels": [{ "id": 895, "name": "RCA", "catno": "PB 41447" }],
    "catalogNumber": "PB 41447",
    "year": 1987,
    "country": "UK",
    "genres": ["Electronic", "Pop"],
    "styles": ["Euro-Disco"],
    "formats": [{ "name": "Vinyl", "qty": 1, "descriptions": ["7\"", "45 RPM", "Single", "Stereo"] }],
    "lowestPrice": 0.89,
    "numForSale": 115,
    "currency": "USD",
    "haveCount": 4049,
    "wantCount": 579,
    "wantHaveRatio": 0.143,
    "ratingAverage": 3.84,
    "ratingCount": 232,
    "dataQuality": "Correct",
    "masterId": 53759,
    "trackCount": 2,
    "url": "https://www.discogs.com/release/249504",
    "marketplaceUrl": "https://www.discogs.com/sell/release/249504",
    "scrapedAt": "2026-06-17T12:00:00.000Z"
}
```

A marketplace **seller** lead (`type: "seller"`):

```json
{
    "type": "seller",
    "username": "recordsbymail",
    "location": "Portland, OR",
    "numForSale": 162928,
    "sellerRating": 99.7,
    "sellerNumRatings": 39359,
    "website": "https://www.recordsbymail.com",
    "leadScore": 90,
    "url": "https://www.discogs.com/user/recordsbymail",
    "scrapedAt": "2026-06-17T12:00:00.000Z"
}
```

Fields are `null` only when Discogs genuinely doesn't have them.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to monitor new releases or price changes for an artist, label, or genre.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (price alert, CRM import, Slack message) the moment a run finishes.

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

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

const run = await client.actor('scrapesage/discogs-scraper').call({
    searchTerms: ['Blue Note'],
    searchType: 'release',
    format: 'Vinyl',
    includeReleaseDetails: true,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Discogs records`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push records or seller leads straight into your CRM or sheet.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new records.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the cheapest copies of Daft Punk – Discovery on vinyl and their want/have demand" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **music & marketplace data stack**:

- **[Reverb Scraper](https://apify.com/scrapesage/reverb-scraper)** — musical-instrument & gear marketplace listings, price guide & seller leads.
- **[SoundCloud Scraper](https://apify.com/scrapesage/soundcloud-scraper)** — artists, tracks & creator leads.
- **[Apple Podcasts Scraper](https://apify.com/scrapesage/apple-podcasts-scraper)** — shows, episodes, reviews & host leads.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — channels, videos & creator leads.
- **[Substack Scraper](https://apify.com/scrapesage/substack-scraper)** — newsletters, posts & creator leads.
- **[eBay Scraper](https://apify.com/scrapesage/ebay-scraper)** — listings, sold prices & seller leads.
- **[Poshmark Scraper](https://apify.com/scrapesage/poshmark-scraper)** — resale listings, sold comps & seller leads.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones & socials from any seller/label website.

### Tips

- **Best price/demand data**: keep `includeReleaseDetails` on — it adds the lowest price, number for sale, and have/want demand that thin scrapers miss.
- **Faster, lighter dumps**: turn `includeReleaseDetails` off to pull a large catalog quickly (search rows still include title, artist, label, year, format and have/want).
- **Find under-supplied gems**: sort/filter your export by **wantHaveRatio** — high values mean lots of demand vs few copies owned.
- **Rate limits**: Discogs allows 25 requests/min unauthenticated; add a free `discogsToken` to get 60/min. The actor already uses a fresh proxy IP per request to spread limits.
- **Seller leads**: add `sellerUsernames` (or paste `/seller/<name>` URLs) and turn on `includeSellerInventory` for a sample of their stock; pair with the [Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper) to get dealer emails.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to receive only new releases/pressings each run.

### FAQ

**Do I need a Discogs API key?** No. The actor works keyless. A free personal token (`discogsToken`) is optional and only raises the rate limit for faster runs.

**Where do the prices come from?** From the Discogs marketplace — `lowestPrice` is the cheapest current copy for sale and `numForSale` is how many copies are listed, in your chosen `currency`.

**What's the difference between a release and a master?** A **master** is the album in the abstract; a **release** is one specific pressing of it (a country/format/year/label edition). Prices and marketplace data live on releases.

**Can I get seller emails?** Discogs doesn't publish member emails. The actor returns each seller's **store website** when they list one — feed those into the [Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper) to extract emails.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new releases or pressings?** Turn on `monitorMode`, set a `monitorKey`, and create a [Schedule](https://docs.apify.com/platform/schedules). Each run emits only records not seen before.

**Is scraping Discogs legal?** This actor uses the official public Discogs API and collects publicly available catalog and marketplace data. You are responsible for complying with Discogs' API terms and applicable laws.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

What to search the Discogs database for — an album, artist, label, catalog number or barcode, e.g. <code>Nirvana Nevermind</code>, <code>Daft Punk</code>, <code>Blue Note</code>. Combined with the filters below. Leave empty to search by filters only.

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

What kind of records to return for keyword searches. <b>Release</b> = a specific pressing (with price & marketplace data). <b>Master</b> = the album across all its versions. <b>Artist</b> / <b>Label</b> = profiles. <b>All</b> mixes every type.

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

Filter by Discogs genre, e.g. <code>Electronic</code>, <code>Rock</code>, <code>Jazz</code>, <code>Hip Hop</code>, <code>Funk / Soul</code>.

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

Filter by sub-style, e.g. <code>House</code>, <code>Techno</code>, <code>Synth-pop</code>, <code>Hard Bop</code>.

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

Filter by release year, e.g. <code>2001</code>. Use a range in the keyword box (Discogs also accepts <code>1990-1999</code>).

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

Filter by country of release, e.g. <code>US</code>, <code>UK</code>, <code>Germany</code>, <code>Japan</code>.

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

Filter by format, e.g. <code>Vinyl</code>, <code>CD</code>, <code>Cassette</code>, <code>LP</code>, <code>Album</code>.

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

Filter by record label, e.g. <code>Warp</code>, <code>Motown</code>, <code>Def Jam</code>.

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

Filter by artist/band name (useful with a genre/format filter and no keyword).

## `startUrls` (type: `array`):

Discogs URLs or IDs to scrape directly: releases (<code>discogs.com/release/249504</code>), masters (<code>/master/13814</code>), artists (<code>/artist/125246</code>), labels (<code>/label/1</code>), or sellers (<code>/seller/\<username></code>). Bare ids like <code>r249504</code>, <code>m13814</code>, <code>l1</code> also work. Used in addition to the search.

## `releaseIds` (type: `array`):

Convenience list of Discogs release IDs to fetch directly (full record with price, demand & tracklist).

## `artistIds` (type: `array`):

Discogs artist IDs to fetch directly (profile, members, websites/socials, optional discography).

## `labelIds` (type: `array`):

Discogs label IDs to fetch directly (profile, sublabels, contact info, websites/socials).

## `sellerUsernames` (type: `array`):

Discogs marketplace seller usernames to turn into B2B record-dealer leads (location, inventory size, seller rating, website/socials & a 0–100 lead score).

## `includeSellerInventory` (type: `boolean`):

For each seller, also pull a sample of their for-sale listings (item, condition, price, currency).

## `sellerInventoryLimit` (type: `integer`):

How many of each seller's listings to include (highest-priced first).

## `includeReleaseDetails` (type: `boolean`):

Open each release/master for the full record: lowest marketplace price, number for sale, community have/want demand, rating, tracklist count, images & videos. Adds one API call per record (turn off for a faster, lighter catalog dump).

## `includeTracklist` (type: `boolean`):

Add the full tracklist (position, title, duration) to each release. Requires full details.

## `includeVideos` (type: `boolean`):

Add linked YouTube videos (title, url, duration) to each release.

## `includeNotes` (type: `boolean`):

Add the release notes text to each release.

## `includeArtistDiscography` (type: `boolean`):

For artists, add their release count and top 10 releases; for labels, add their catalog size. Adds one API call per artist/label.

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

Currency for marketplace prices (lowest price & listings), e.g. <code>USD</code>, <code>EUR</code>, <code>GBP</code>, <code>JPY</code>, <code>AUD</code>, <code>CAD</code>.

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

Maximum number of records to scrape across all searches and targets.

## `deduplicate` (type: `boolean`):

Drop duplicate records that match more than one keyword/target in the same run.

## `monitorMode` (type: `boolean`):

Remember record ids across runs in a named key-value store and emit ONLY records not seen before. Pair with Apify Schedules to track new releases for an artist/label, new pressings, or newly listed items — it complements the scheduler (the schedule starts the run, monitor mode dedupes against prior runs).

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

Names the monitor's memory store so you can run several independent monitors (e.g. one per artist or genre). Reuse the same key to keep tracking the same feed.

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

Optional free personal access token from your Discogs account (Settings → Developers). Raises the rate limit from 25 to 60 requests/minute for faster runs. Not required — the actor works without it.

## `maxConcurrency` (type: `integer`):

Parallel API fetches. Each request uses a fresh proxy IP to spread Discogs' per-IP rate limit.

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

Proxies to use. Datacenter (the default) is clean and cheap for the Discogs API; a fresh session per request spreads the per-IP rate limit.

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

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "searchTerms": [
    "Daft Punk Discovery"
  ],
  "searchType": "release",
  "includeSellerInventory": false,
  "sellerInventoryLimit": 25,
  "includeReleaseDetails": true,
  "includeTracklist": false,
  "includeVideos": false,
  "includeNotes": false,
  "includeArtistDiscography": false,
  "currency": "USD",
  "maxResults": 100,
  "deduplicate": true,
  "monitorMode": false,
  "monitorKey": "default",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped Discogs records (releases, masters, artists, labels & seller leads) as JSON items in the default dataset.

# 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": [
        "Daft Punk Discovery"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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": ["Daft Punk Discovery"],
    "proxyConfiguration": { "useApifyProxy": True },
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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": [
    "Daft Punk Discovery"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "urlsFromFile": ""
}' |
apify call scrapesage/discogs-scraper --silent --output-dataset

```

## MCP server setup

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