# Discogs Release Prices & Vinyl Collector Price Watch (`superslowsloth/discogs-prices`) Actor

Lowest marketplace price and copies for sale for Discogs releases, one flat row each: title, artists, year, format, label, country, genres, community have/want and rating. Find releases by search, artist, label, master or id. No token.

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

## Pricing

from $3.15 / 1,000 release priceds

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/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 Release Prices & Vinyl Collector Price Watch

Price [Discogs](https://www.discogs.com) releases in bulk. For each release you
get one flat row: the **lowest marketplace price right now**, how many copies
are for sale, and the release's own details - title, artists, year, format,
label, catalogue number, country, genres, styles - with how many collectors
**have** and **want** it and its rating. Find releases by search term, artist,
label, master (all pressings of one album) or by a list of ids and URLs, and
run it on a schedule as a **record collector's price watch**.

No account, no API token, no login, no browser.

### Input

| Field | Notes |
|---|---|
| `releases` | Release ids or URLs, one per line: `249504`, `r249504` or `https://www.discogs.com/release/249504-...`. The watchlist route; read first. |
| `queries` | Search terms, one per line (artist, title, catalogue number). Releases only. |
| `artistIds` | Artist ids or URLs. Every release in the artist's discography. A master in it is priced through its main release. |
| `labelIds` | Label ids or URLs. Every release on the label. Big labels have hundreds of thousands, so set `maxItems`. |
| `masterIds` | Master ids or URLs. Every version (pressing, reissue, format) of the master. |
| `maxItems` | Stop after this many rows in total across all sources (default 100, up to 10,000). |
| `currency` | `USD` (default), `GBP`, `EUR`, `CAD`, `AUD`, `JPY`, `CHF`, `MXN`, `BRL`, `NZD`, `SEK` or `ZAR`. |
| `proxyConfiguration` | Apify proxy by default. |

Supply at least one of `releases`, `queries`, `artistIds`, `labelIds`,
`masterIds`. A release found by more than one route is returned and billed once,
under the first route that found it (`found_via`). Routes run in the order
listed above.

### Output

| Field | Notes |
|---|---|
| `release_id`, `url` | Discogs' numeric id and the release page. |
| `title`, `artists` | The release title (Discogs does not put the artist in it) and the credited artist names. |
| `lowest_price`, `currency` | The cheapest copy for sale now, **without shipping**, and the currency it is quoted in. |
| `num_for_sale` | Copies listed for sale now. |
| `blocked_from_sale` | True when Discogs does not allow the release to be sold. |
| `have`, `want` | Collectors who own / want the release. |
| `rating_average`, `rating_count` | Community rating (1 to 5) and the number of ratings. |
| `year`, `released`, `country` | Year, the release date exactly as Discogs writes it (`1987-07-00` is July 1987), country of release. |
| `formats` | Format and descriptions: `["Vinyl", "7\"", "45 RPM", "Single", "Stereo"]`. |
| `labels`, `catalog_numbers` | Label names and catalogue numbers. |
| `genres`, `styles` | Discogs' genres and styles. |
| `master_id`, `thumbnail_url` | The master release it belongs to, and a 150 px cover thumbnail. |
| `status`, `data_quality` | Discogs' own review state and data-quality grade. |
| `found_via` | The route that found the release (`release 249504`, `search: ...`, `artist 72872`, `label 895`, `master 96559`). |
| `fetched_at` | When the price was read (ISO 8601 UTC), so two runs can be compared. |

#### Honest nulls

A field Discogs did not send is `null`, never `0`:

- `lowest_price` is **null when no copy is for sale** (`num_for_sale` is `0`).
  A release nobody sells has no price; it does not cost 0. The row is still
  returned, because "nothing for sale" is the answer a price watch is asking for.
- `currency` is set on every row, including those with a null price: it is the
  currency you asked for.
- `rating_average` is null when nobody has rated the release (Discogs sends
  `0.0` with a count of `0`). `have` and `want` can be a genuine `0`.
- `year` is null when Discogs holds none (it sends `0`); `master_id` is null for
  a release that belongs to no master.
- A release Discogs answers 404 for (a deleted or never-existing id) produces no
  row, no charge, and a line in the run log.

`lowest_price` is the **cheapest asking price**, not a sale price or a market
value. It is also the cheapest copy in any condition.

### Pricing

Pay per event:

- **$0.002** per run (`actor-start`), charged only after your input is
  validated, so a run that fails on bad input costs nothing.
- **$0.00035** per release row written (`release-scraped`), i.e. $0.35 per
  1,000 releases.

### How it fetches, and how fast it is

It calls Discogs' public API (`api.discogs.com`) without a token. Per release it
makes **one request in US dollars** (`/releases/<id>` carries the price and the
count next to the details) and **two in any other currency** (only
`/marketplace/stats/<id>` converts). Discovery routes add one request per 100
releases found.

**Discogs allows 25 requests a minute per address without a token.** That is the
speed limit of this actor. With the default Apify proxy, the actor reads the
remaining allowance from every response and moves to a fresh address when it is
spent, so a run keeps going; without a proxy it waits a minute each time, which
is about 24 releases a minute. Plan on minutes, not seconds, for a thousand
releases, and pick `USD` for the fastest run.

Things worth knowing, all measured on 2026-10-13:

- **The request is identified.** Discogs requires a descriptive User-Agent and
  refused (HTTP 403) one that named the hosting platform, so the actor sends its
  own product name.
- **Search stops at 10,000 results** (100 pages of 100). Narrow the term or use
  the artist, label or master routes to go past it.
- **A master id that does not exist is checked first.** Discogs' version list
  answers 200 with its entire catalogue (8 million releases) for an unknown
  master id, so the actor confirms the master exists before reading its versions.
  An unknown id is reported as not found and costs one request.
- **Prices move.** `fetched_at` is when the price was read; a release can sell
  out or be undercut a minute later.
- **Stops early rather than burning your credit.** If five releases in a row
  cannot be read (a blocked address), the run stops and says why.

# Actor input Schema

## `releases` (type: `array`):

Specific releases to price, one per line: a release id (249504), the form Discogs shows in collections (r249504) or a release page URL (https://www.discogs.com/release/249504-Rick-Astley-Never-Gonna-Give-You-Up). Use this for a watchlist run on a schedule. These are read first.

## `queries` (type: `array`):

What you would type into Discogs' search box, one term per line (for example rick astley never gonna give you up, or a catalogue number such as PB 41447). Releases only; each term is read page by page, 100 releases per request.

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

Price every release in an artist's discography: the numeric artist id (72872) or the artist page URL (https://www.discogs.com/artist/72872-Rick-Astley). A master in the discography is priced through its main release.

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

Price every release on a record label: the numeric label id (895) or the label page URL (https://www.discogs.com/label/895-RCA). Big labels hold hundreds of thousands of releases, so set Max releases.

## `masterIds` (type: `array`):

Price every version (pressing, reissue, format) of a master release: the numeric master id (96559) or the master page URL (https://www.discogs.com/master/96559-Rick-Astley-Never-Gonna-Give-You-Up). A master id Discogs does not know is reported as not found rather than read.

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

Stop after this many release rows in total, across all of the sources above. Discogs allows 25 requests a minute per address, and each release costs one request in US dollars (two in another currency), so large runs take a while.

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

Currency for the lowest price. US dollars needs one request per release; any other currency needs a second request per release because only Discogs' marketplace stats route converts. Every row states the currency it is quoted in.

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

Apify proxy (automatic datacenter exits) is the default. Discogs allows 25 requests a minute per address, so the actor moves to a fresh address when one runs out; without a proxy it waits a minute instead, and a run is far slower.

## Actor input object example

```json
{
  "releases": [
    "249504"
  ],
  "maxItems": 100,
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "releases": [
        "249504"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/discogs-prices").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 = {
    "releases": ["249504"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/discogs-prices").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 '{
  "releases": [
    "249504"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/discogs-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/discogs-prices"
        }
    }
}
```

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/Fo6CHeG3uWH6pRjXf/builds/zJe4sosXwF9T0gbGM/openapi.json