# Discogs Music & Marketplace Scraper (`hipersoft/discogs-scraper`) Actor

Search Discogs for vinyl, CD & digital releases: artists, labels, year, country, genres, styles, formats, tracklist, cover art — plus marketplace price (lowest, copies for sale) and community have/want & rating. For record sellers, collectors and music data. No key needed.

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

## Pricing

from $0.0012 / item scraped

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Discogs Music & Marketplace Scraper — Releases, Prices & Community Stats

Search Discogs for vinyl, CD, and digital releases and get back clean structured JSON: artists, labels, year, country, genres, styles, formats, cover art — plus marketplace price and community demand. Filter by genre, style, country, year, and format, or fetch specific release IDs directly. No API key needed (though an optional token speeds up big jobs). Built for record sellers, collectors, and music data teams.

### Features
- 💿 **Rich release records** — `title`, `artists`, `labels`, `year`, `country`, `genres`, `styles`, `formats`, `catno`, and `coverImage`.
- 💰 **Marketplace pricing** — `includeMarketplace` adds `lowestPrice` and `numForSale` per release.
- 📈 **Community demand** — `haveCount`, `wantCount`, `ratingAvg`, and `ratingCount` reveal collectibility at a glance.
- 🎛️ **Powerful filters** — narrow searches by `genre`, `style`, `country`, `yearFilter`, and `format`.
- 🔀 **Four entity types** — set `searchType` to release, master, artist, or label.
- 🎯 **Direct ID fetch** — pass `releaseIds` to grab specific pressings without searching.
- ⚡ **Optional token** — supply a free `discogsToken` to raise the rate limit and finish large runs faster.

### What you get
Each result is one clean JSON record (with marketplace/community stats when enabled):
```json
{
  "query": "radiohead ok computer",
  "id": 249504,
  "type": "release",
  "title": "Radiohead - OK Computer",
  "year": 1997,
  "country": "UK & Europe",
  "genres": ["Rock"],
  "styles": ["Alternative Rock"],
  "formats": ["Vinyl", "LP", "Album"],
  "labels": ["Parlophone"],
  "catno": "NODATA 01",
  "barcode": ["7243 8 55229 1 4"],
  "thumb": "https://i.discogs.com/.../150.jpg",
  "coverImage": "https://i.discogs.com/.../full.jpg",
  "discogsUrl": "https://www.discogs.com/release/249504",
  "resourceUrl": "https://api.discogs.com/releases/249504",
  "released": "1997-06-16",
  "artists": ["Radiohead"],
  "trackCount": 12,
  "haveCount": 42150,
  "wantCount": 18700,
  "ratingAvg": 4.62,
  "ratingCount": 5120,
  "numForSale": 310,
  "lowestPrice": 24.99
}
````

### Input

```json
{
  "searchQueries": ["radiohead ok computer", "miles davis"],
  "searchType": "release",
  "genre": "Rock",
  "format": "Vinyl",
  "includeMarketplace": true,
  "maxResultsPerQuery": 50
}
```

| Field | Description |
| --- | --- |
| `searchQueries` | Artist, release, or free-text queries. |
| `searchType` | `release`, `master`, `artist`, or `label`. |
| `genre` / `style` / `country` / `yearFilter` / `format` | Optional search filters. |
| `releaseIds` | Fetch specific release IDs directly (skips search). |
| `includeMarketplace` | Add price + have/want + rating per release. |
| `maxResultsPerQuery` | Max items per query (up to 2000). |
| `discogsToken` | Optional token to raise the rate limit. |

### Use cases

- Price vinyl inventory by pulling lowest price and copies for sale.
- Spot collectible pressings using have/want ratios and ratings.
- Build a music catalog with clean genre, style, and format metadata.
- Research an artist's or label's discography across pressings.

### Pricing

Pay-per-event: you're billed a small amount per run and per item scraped — you only pay for what you get. See the **Pricing** tab for current rates.

### FAQ

**Do I need a Discogs account or API key?**
No API key is required — the Actor runs over [Discogs](https://www.discogs.com)' public API out of the box. You can optionally supply a free `discogsToken` to raise the rate limit and finish large runs faster.

**How many releases can I get per run?**
Set `maxResultsPerQuery` up to 2,000 per query, with pagination handled automatically. Pass multiple queries in `searchQueries` to scale further.

**Can I download music or audio?**
No. This Actor reads only public catalog, marketplace and community data — release metadata, prices and have/want stats. It does not download any audio.

**What's the output format?**
Each result is one clean JSON record, with marketplace and community stats included when `includeMarketplace` is on. Export as JSON, CSV or Excel.

**Can I filter by genre, format, country or year?**
Yes. Narrow searches with `genre`, `style`, `country`, `yearFilter` and `format`, or skip search entirely by passing specific `releaseIds`.

### Related Actors

Building a music dataset? Pair this with our other music and media scrapers:

- [Spotify Scraper](https://apify.com/hipersoft/spotify-scraper) — tracks, artists, albums and playlists with no login or API key.
- [SoundCloud Scraper](https://apify.com/hipersoft/soundcloud-scraper) — tracks, artists and playlists with play counts, likes and followers.
- [Deezer Scraper](https://apify.com/hipersoft/deezer-scraper) — tracks, artists, albums, playlists and global top charts with ISRCs.
- [Apple Podcasts Scraper](https://apify.com/hipersoft/apple-podcasts-scraper) — podcast shows and episodes with RSS feeds and artwork.

### Notes

This Actor uses Discogs' public API and reads only public catalog, marketplace, and community data. It is an independent tool and is not affiliated with, endorsed by, or connected to Discogs (Zink Media, LLC).

# Actor input Schema

## `searchQueries` (type: `array`):

Artist, release, or free-text queries to search on Discogs (e.g. "nirvana nevermind", "blue note jazz").

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

What kind of Discogs entity to return.

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

Optional genre filter, e.g. Rock, Electronic, Jazz, Hip Hop.

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

Optional style filter, e.g. House, Techno, Bebop, Shoegaze.

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

Optional country of release, e.g. US, UK, Germany, Japan.

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

Optional release year, e.g. 1991.

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

Optional format filter, e.g. Vinyl, CD, Cassette, LP, Album.

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

Optional. Fetch these specific Discogs release IDs directly (search queries are ignored when set).

## `includeMarketplace` (type: `boolean`):

Fetch each release's lowest price, copies for sale, have/want counts and rating. Adds one API call per release (slower, richer). Turn off for a fast lightweight list.

## `maxResultsPerQuery` (type: `integer`):

Maximum items to collect per search query.

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

Optional personal Discogs API token (free at discogs.com/settings/developers) — raises the rate limit from 25 to 60 requests/min, so large jobs finish faster.

## Actor input object example

```json
{
  "searchQueries": [
    "daft punk discovery",
    "miles davis"
  ],
  "searchType": "release",
  "genre": "",
  "style": "",
  "country": "",
  "yearFilter": "",
  "format": "",
  "releaseIds": [
    "249504",
    "1813006"
  ],
  "includeMarketplace": true,
  "maxResultsPerQuery": 50
}
```

# 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 = {
    "searchQueries": [
        "radiohead ok computer"
    ],
    "releaseIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = {
    "searchQueries": ["radiohead ok computer"],
    "releaseIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/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 '{
  "searchQueries": [
    "radiohead ok computer"
  ],
  "releaseIds": []
}' |
apify call hipersoft/discogs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hipersoft/discogs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discogs Music & Marketplace Scraper",
        "description": "Search Discogs for vinyl, CD & digital releases: artists, labels, year, country, genres, styles, formats, tracklist, cover art — plus marketplace price (lowest, copies for sale) and community have/want & rating. For record sellers, collectors and music data. No key needed.",
        "version": "1.0",
        "x-build-id": "iXEIf7xc8u85FxYqj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hipersoft~discogs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hipersoft-discogs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/hipersoft~discogs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hipersoft-discogs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/hipersoft~discogs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hipersoft-discogs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Artist, release, or free-text queries to search on Discogs (e.g. \"nirvana nevermind\", \"blue note jazz\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Result type",
                        "enum": [
                            "release",
                            "master",
                            "artist",
                            "label"
                        ],
                        "type": "string",
                        "description": "What kind of Discogs entity to return.",
                        "default": "release"
                    },
                    "genre": {
                        "title": "Genre filter",
                        "type": "string",
                        "description": "Optional genre filter, e.g. Rock, Electronic, Jazz, Hip Hop.",
                        "default": ""
                    },
                    "style": {
                        "title": "Style filter",
                        "type": "string",
                        "description": "Optional style filter, e.g. House, Techno, Bebop, Shoegaze.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country filter",
                        "type": "string",
                        "description": "Optional country of release, e.g. US, UK, Germany, Japan.",
                        "default": ""
                    },
                    "yearFilter": {
                        "title": "Year filter",
                        "type": "string",
                        "description": "Optional release year, e.g. 1991.",
                        "default": ""
                    },
                    "format": {
                        "title": "Format filter",
                        "type": "string",
                        "description": "Optional format filter, e.g. Vinyl, CD, Cassette, LP, Album.",
                        "default": ""
                    },
                    "releaseIds": {
                        "title": "Release IDs",
                        "type": "array",
                        "description": "Optional. Fetch these specific Discogs release IDs directly (search queries are ignored when set).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeMarketplace": {
                        "title": "Include marketplace & community stats",
                        "type": "boolean",
                        "description": "Fetch each release's lowest price, copies for sale, have/want counts and rating. Adds one API call per release (slower, richer). Turn off for a fast lightweight list.",
                        "default": true
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum items to collect per search query.",
                        "default": 50
                    },
                    "discogsToken": {
                        "title": "Discogs token (optional)",
                        "type": "string",
                        "description": "Optional personal Discogs API token (free at discogs.com/settings/developers) — raises the rate limit from 25 to 60 requests/min, so large jobs finish faster."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
