# Discogs Vinyl Records Price Guide (`phoenixcapital/discogs-vinyl-price-scraper`) Actor

Search Discogs music database and get current marketplace prices for vinyl records, CDs, and cassettes. No auth required.

- **URL**: https://apify.com/phoenixcapital/discogs-vinyl-price-scraper.md
- **Developed by:** [Anthony Ts](https://apify.com/phoenixcapital) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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 Vinyl Records Price Guide Scraper

Search the **Discogs** music database and get **live marketplace prices** for vinyl records, CDs, cassettes, and more — all via the public Discogs REST API. No browser, no proxy, no authentication required.

### Why this scraper?

Discogs is the world's largest music database and marketplace, with millions of records listed for sale. Dealers, collectors, and resellers constantly need to know:

- **How many copies** of a specific pressing are currently for sale?
- **What is the lowest current asking price?**
- **Which pressings are most affordable** for a given album?

This scraper answers all three questions by combining Discogs database search with live marketplace statistics.

### What you get

Each result includes:

| Field | Description |
|-------|-------------|
| `releaseId` | Discogs release ID |
| `title` | Album/release title |
| `artist` | Artist name |
| `year` | Release year |
| `country` | Country of release |
| `label` | Record label |
| `catno` | Catalog number |
| `format` | Full format description (e.g. "Vinyl, LP, Album, Original") |
| `genre` | Music genre(s) |
| `style` | Music style(s) |
| `numForSale` | Number of copies currently for sale on Discogs |
| `lowestPrice` | Current lowest asking price |
| `lowestPriceCurrency` | Price currency |
| `marketAvailable` | Whether any copies are currently for sale |
| `discogsUrl` | Link to release page |
| `marketplaceUrl` | Direct link to buy listings |

### Input parameters

```json
{
  "query": "pink floyd dark side",
  "format": "vinyl",
  "country": "US",
  "yearMin": 1970,
  "yearMax": 1980,
  "maxItems": 50
}
```

| Parameter | Type | Description |
|-----------|------|-------------|
| `query` | string | Keyword search (artist + album) |
| `artist` | string | Artist name (alternative to query) |
| `album` | string | Album title (alternative to query) |
| `format` | string | Format: `vinyl`, `CD`, `Cassette`, etc. (default: `vinyl`) |
| `genre` | string | Genre: `Rock`, `Jazz`, `Electronic`, `Hip Hop`, etc. |
| `style` | string | Style: `Blues Rock`, `Bebop`, `Ambient`, etc. |
| `country` | string | Country of release: `US`, `UK`, `Germany`, etc. |
| `yearMin` | integer | Minimum release year |
| `yearMax` | integer | Maximum release year |
| `barcode` | string | Exact barcode search |
| `maxItems` | integer | Max results (default: 25) |

### Use cases

- **Record dealers**: Price your inventory against current market rates
- **Collectors**: Find which pressing of an album is most affordable
- **Flippers**: Spot arbitrage opportunities between regions/years
- **Price tracking**: Monitor how market prices change over time
- **Discography research**: Discover all pressings of an album with availability

### Sample output

```json
{
  "releaseId": 4121673,
  "title": "Abbey Road",
  "artist": "The Beatles",
  "year": 1969,
  "country": "UK",
  "label": "Apple Records",
  "catno": "PCS 7088",
  "format": "Vinyl, LP, Album",
  "genre": ["Rock"],
  "style": ["Pop Rock"],
  "numForSale": 127,
  "lowestPrice": 5.33,
  "lowestPriceCurrency": "USD",
  "marketAvailable": true,
  "discogsUrl": "https://www.discogs.com/release/4121673",
  "marketplaceUrl": "https://www.discogs.com/sell/release/4121673"
}
```

### Notes

- Rate limited to ~24 requests/minute (Discogs public API limit). For large `maxItems` values, runs may take several minutes.
- Discogs returns marketplace stats in USD by default; other currencies may appear for non-US sellers.
- Price data reflects current Discogs marketplace listings and updates in real-time.

# Actor input Schema

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

Keyword search: artist name, album title, or both (e.g. 'pink floyd dark side').

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

Filter by artist name (used when query is not set).

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

Filter by album/release title (used when query is not set).

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

Record format: Vinyl, CD, Cassette, etc.

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

Music genre (e.g. Rock, Jazz, Electronic, Hip Hop).

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

Music style (e.g. Blues Rock, Bebop, Ambient).

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

Country of release (e.g. US, UK, Germany).

## `yearMin` (type: `integer`):

Minimum release year.

## `yearMax` (type: `integer`):

Maximum release year.

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

Search by exact barcode.

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

Maximum number of records to return (default: 25, max: 500).

## Actor input object example

```json
{
  "format": "vinyl",
  "maxItems": 25
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("phoenixcapital/discogs-vinyl-price-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("phoenixcapital/discogs-vinyl-price-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 '{}' |
apify call phoenixcapital/discogs-vinyl-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/gq9edAtLA7jfeDc63/builds/EUw8ukAjTeCBuyKK5/openapi.json