# Discogs Scraper - Vinyl Records, Prices & Price Stats (`abotapi/discogs-scraper`) Actor

Scrape the Discogs catalogue by keyword, filter or link: releases, masters, artists and labels with tracklists, credits, matrix numbers, images and videos. Cross-pressing price statistics: lowest, median, highest and average asking price across an album's pressings, plus want/have demand.

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

## Pricing

from $1.20 / 1,000 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 Records, Prices & Price Stats

Scrape the world's largest music database and marketplace: 17M+ releases, every
pressing, every label, every artist. Search by keyword or filter, or paste
release / master / artist / label links, and get clean structured records with
tracklists, credits, matrix numbers, images, videos and live marketplace prices.

**The headline feature: price statistics across an album's pressings.** One
pressing's "lowest price" tells you almost nothing, because the
same album exists as dozens of pressings whose prices differ by two orders of
magnitude. Turn on **Price statistics** and every record carries the **lowest,
median, highest and average** asking price across the album's pressings, how
many copies are for sale in total, and the want-to-have demand ratio collectors
use to judge scarcity.

### What you get

- **Price statistics** across an album's pressings: lowest, median, highest and
  average asking price, plus how many copies are for sale in total.
- **Want-to-have demand ratio**, per pressing and per album, the number
  collectors use to judge scarcity.
- **Per-condition valuation**, Mint through Poor, with your own free Discogs
  token.
- **Four record kinds**: release, master, artist and label.
- **Nine typed filters**: artist, label, genre, style, format, country, year,
  catalog number and barcode. They work with a keyword, and on their own.
- **Full sort control**, including most wanted and most collected.
- **Twelve currencies** for every price.
- **Incremental change tracking and resume**, for scheduled monitoring.
- **Every column always present**, `null` when a run does not fill it, so
  repeated runs join cleanly.
- **A blocked run fails loudly** instead of quietly returning "0 results".

### Data you get

Every record carries `kind` (`release`, `master`, `artist` or `label`),
`recordId`, `entityId`, `url`, `sourceMode`, `searchQuery`, `detailLoaded`,
`priceStatsLoaded` and `scrapedAt`. Columns that a given run does not fill are
present as `null`, never dropped, so repeated runs join cleanly in a warehouse.

**Release and master fields**
`title`, `artistName`, `artistNames`, `artistsSort`, `artists`, `extraArtists`
(producers, engineers, writers, with their roles), `year`, `released`,
`releasedFormatted`, `country`, `genres`, `styles`, `formats`,
`formatDescriptions`, `formatQuantity`, `labels`, `labelNames`,
`catalogNumber`, `barcodes`, `identifiers` (matrix / runout, rights society,
label code), `companies` (pressing plant, publisher, copyright), `series`,
`masterId`, `masterUrl`, `mainReleaseId`, `mostRecentReleaseId`, `tracklist`,
`trackCount`, `images`, `imageCount`, `coverImageUrl`, `thumbnailUrl`,
`videos`, `videoCount`, `notes`, `estimatedWeight`, `dataQuality`, `status`,
`dateAdded`, `dateChanged`, `submitterUsername`, `contributorUsernames`,
`isOffensive`.

**Marketplace fields**
`numForSale`, `lowestPrice`, `currency`, `blockedFromSale`, `marketplaceUrl`,
`haveCount`, `wantCount`, `wantToHaveRatio`, `ratingAverage`, `ratingCount`.

**Price statistics (the differentiator, with Price statistics on)**
`priceLowest`, `priceMedian`, `priceHighest`, `priceAverage`, `priceCurrency`,
`priceVersionsSampled`, `priceVersionsPriced`, `masterVersionsTotal`,
`totalForSaleAcrossVersions`, `masterHaveCount`, `masterWantCount`,
`masterWantToHaveRatio`.

Pressings with nothing for sale are counted in `priceVersionsSampled` but never
priced as `0`, so a dead pressing cannot drag the statistics down.

**Per-condition valuation (only with your own Discogs token)**
`priceSuggestionMint`, `priceSuggestionNearMint`, `priceSuggestionVeryGoodPlus`,
`priceSuggestionVeryGood`, `priceSuggestionGoodPlus`, `priceSuggestionGood`,
`priceSuggestionFair`, `priceSuggestionPoor`, `priceSuggestionCurrency`,
`priceSuggestionsRaw`.

**Artist fields**
`name`, `realName`, `profile`, `nameVariations`, `aliases`, `members`,
`groups`, `externalUrls` (official site and socials), `images`, `releasesUrl`,
`contactEmails`, `contactPhones`.

**Label fields**
`name`, `profile`, `contactInfo`, `contactEmails`, `contactPhones`,
`parentLabelId`, `parentLabelName`, `subLabels`, `subLabelCount`,
`externalUrls`, `images`, `releasesUrl`.

### How to use

1. Pick a **mode**. `search` runs keyword and filter searches; `url` reads the
   exact pages you paste.
2. Search mode: add `searchQueries`, choose `searchType`, and narrow with any
   of `artist`, `label`, `genre`, `style`, `format`, `country`, `year`,
   `catalogNumber`, `barcode`. Filters work on their own with no keyword, so
   "every Blue Note vinyl pressed in Japan in 1963" is a valid run with no
   search box at all. Order the results with `sortBy` and `sortOrder`.
3. URL mode: paste links into `startUrls` (or the `urls` alias). Full links,
   `/release/249504` paths, the `r249504` / `m13814` / `a72872` / `l895`
   shorthand and plain release ids all work, and all four kinds can be mixed.
4. Set `maxItems` (the run's cap, default 20). Leave `maxPages` empty for no
   page limit.
5. Turn on `priceStats` for the price distribution, and `maxPriceVersions` to
   choose how deeply to sample. Turn on `fetchDetails` for tracklists, credits
   and images in search mode. Choose your `currency`.

#### Input parameters

| Field | What it does |
|---|---|
| `mode` | `search` or `url`. |
| `searchQueries` | Search mode. Keywords, each searched separately. |
| `searchType` | Search mode. `release`, `master`, `artist`, `label` or `all`. |
| `artist` | Search mode filter. |
| `label` | Search mode filter. |
| `genre` | Search mode filter, for example `Rock`, `Jazz`, `Electronic`. |
| `style` | Search mode filter, for example `Grunge`, `Hard Bop`. |
| `format` | Search mode filter, for example `Vinyl`, `LP`, `CD`. |
| `country` | Search mode filter, for example `UK`, `Japan`. |
| `year` | Search mode filter, a year or a `1990-1995` range. |
| `catalogNumber` | Search mode filter on the label catalog number. |
| `barcode` | Search mode filter on the barcode / UPC / EAN. |
| `sortBy` | Search mode. `relevance`, `year`, `title`, `format`, `label`, `catno`, `country`, `have` (most collected) or `want` (most wanted). |
| `sortOrder` | Search mode. `desc` or `asc`. |
| `startUrls` | URL mode. Catalogue links, paths or ids. |
| `urls` | Alias for `startUrls`. |
| `maxItems` | The run's cap. Default 20, `0` for no limit. |
| `maxPages` | Search mode. Empty means no page limit. |
| `fetchDetails` | Search mode: read each result's full record. URL mode always does. |
| `priceStats` | Build the price distribution across the album's pressings. |
| `maxPriceVersions` | How many pressings to price per album (default 5, max 25). |
| `currency` | One of 12 currencies for every price. |
| `resumeFromRunId` | Continue one interrupted run without re-charging for records already collected. |
| `incrementalMode` | Return only what changed since the last run of the same setup. |
| `stateKey` | Name a monitoring campaign, or deliberately share state. |
| `emitUnchanged` | Also return (and bill) `UNCHANGED` rows. |
| `emitExpired` | Also return (and bill) `EXPIRED` rows. |
| `mcpConnectors` | Send results into your apps, see below. |
| `notionParentPageUrl` | Parent page for the Notion export. |
| `maxNotifyListings` | Cap on records written to each connector. |
| `proxyConfiguration` | Apify Proxy settings. The default needs no configuration. |
| `discogsToken` | Optional. Your own free Discogs token, see below. |

#### Output example

Field values below are illustrative, not a real listing.

```json
{
  "kind": "release",
  "recordId": "release:249504",
  "entityId": 249504,
  "sourceMode": "search",
  "searchQuery": "example album",
  "title": "Example Album",
  "artistName": "Example Artist",
  "year": "1991",
  "country": "UK",
  "labelNames": ["Example Records"],
  "catalogNumber": "EX 1234",
  "barcodes": ["0000000000000"],
  "genres": ["Rock"],
  "styles": ["Grunge"],
  "formatDescriptions": ["Vinyl", "LP", "Album"],
  "numForSale": 122,
  "lowestPrice": 10.0,
  "currency": "USD",
  "priceLowest": 10.0,
  "priceMedian": 43.17,
  "priceHighest": 276.63,
  "priceAverage": 115.77,
  "priceVersionsSampled": 5,
  "priceVersionsPriced": 5,
  "masterVersionsTotal": 882,
  "totalForSaleAcrossVersions": 13,
  "priceCurrency": "USD",
  "haveCount": 4107,
  "wantCount": 585,
  "wantToHaveRatio": 0.1424,
  "masterWantToHaveRatio": 0.1429,
  "ratingAverage": 3.86,
  "ratingCount": 241,
  "trackCount": 2,
  "url": "https://www.discogs.com/release/249504",
  "marketplaceUrl": "https://www.discogs.com/sell/release/249504",
  "detailLoaded": true,
  "priceStatsLoaded": true,
  "scrapedAt": "2026-09-04T12:00:00+00:00",
  "changeType": "NEW"
}
```

### Recurring monitoring: track a price over time

Turn on `incrementalMode` and schedule the run. The first run returns everything
as `NEW`; later runs return only what moved. Every record carries `changeType`
(`NEW`, `UPDATED`, `REAPPEARED`, `UNCHANGED` or `EXPIRED`), `changedFields`,
`firstSeenAt` and `lastSeenAt`, so a price move shows up as
`"changeType": "UPDATED", "changedFields": ["lowestPrice", "priceMedian"]`.

State is kept separately per keyword, entity kind, filter, sort and lookup
setup, so two campaigns never mix. `UNCHANGED` and `EXPIRED` rows are off by
default because returning them bills extra rows you already have. `EXPIRED` is
only produced after a run has fully scanned the tracked search: never when
`maxItems` or `maxPages` capped it, and never when `resumeFromRunId` was used,
so a partial scan can never tombstone records that are still there.

To continue ONE interrupted run instead, use `resumeFromRunId` with the previous
run or dataset id; records already collected there are skipped and not charged
again.

### Send results into your apps (MCP connectors)

Set `mcpConnectors` to one or more Model Context Protocol connectors you have
authorized under Apify, Settings, API & Integrations. Notion gets a rich page
per record (set `notionParentPageUrl`); other connectors get a best-effort
write or digest. `maxNotifyListings` caps how many records each connector
receives. This never changes the dataset output, and a connector failure never
fails the run.

### No account needed

Everything this actor returns is data Discogs publishes openly. No Discogs
account, no login, no cookies.

Adding your own **free** `discogsToken` (Discogs, Settings, Developers) is
optional and does two things: large pulls finish faster, and it unlocks the
per-condition valuation fields (`priceSuggestionMint` through
`priceSuggestionPoor`) that Discogs shows only to a signed-in member. Without a
token those fields are present and `null`.

### Connection and reliability

The default Apify Proxy setting works on every plan, including the free tier,
and needs no configuration.

Discogs limits how fast any one client may read, and the actor stays inside
that limit by design rather than by being refused and retrying. If Discogs does
slow a run down, the actor waits it out instead of hammering.

A run that cannot read Discogs at all **fails loudly** with a connection
message. It never reports a block as "0 results found", which would be
indistinguishable from a genuinely empty search, and in incremental mode would
wrongly mark every tracked record as gone.

### Billing

You are charged one **Record** event per row in the dataset, plus one **Detail
enrichment** event per record whose optional extras succeeded (the full record
in search mode, or the price statistics for either mode). Both optional toggles
are off by default, so a default run is charged for records only. An extra that
fails still ships the record, uncharged. In URL mode the full record is the base
record, not an extra, and is never charged.

### Terms note

This actor returns only catalogue and marketplace data that Discogs already
publishes openly. Contact details in `contactEmails` and
`contactPhones` come from a label's or artist's own public profile block, where
they published them themselves. Please respect Discogs' terms of service and
applicable data protection law when you use the output.

# Actor input Schema

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

Search runs keyword and filter searches across the Discogs catalogue. URL mode reads only the exact releases, masters, artists or labels you paste.

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

Search mode only, ignored in URL mode. One or more keywords, for example "nirvana nevermind" or "blue note 1568". Each keyword is searched separately and gets an equal share of Max records. Leave empty to run a filter only search using the filters below.

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

Search mode only. Which kind of catalogue entry the search returns. Releases are individual pressings and are the only kind with marketplace prices. Masters are albums across all their pressings.

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

Search mode only. Restrict results to this artist, for example "Nirvana". Works with or without a keyword.

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

Search mode only. Restrict results to this record label, for example "Sub Pop" or "Blue Note".

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

Search mode only. Restrict results to one Discogs genre, for example "Rock", "Jazz", "Electronic", "Hip Hop", "Funk / Soul", "Classical".

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

Search mode only. Restrict results to one Discogs style, the finer grained tag under a genre, for example "Grunge", "Hard Bop", "Deep House", "Post Punk".

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

Search mode only. Restrict results to one physical or digital format, for example "Vinyl", "LP", "CD", "Cassette", "7"", "Album", "File".

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

Search mode only. Restrict results to the country of the pressing, for example "UK", "US", "Japan", "Germany", "Europe".

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

Search mode only. Restrict results to a release year, for example "1991". A range such as "1990-1995" is also accepted by Discogs.

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

Search mode only. Restrict results to a label catalog number, for example "DGC2-4425" or "BLP 1568". This is the number printed on the spine and label.

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

Search mode only. Restrict results to a barcode or UPC/EAN, for example "720642442517". The fastest way to identify an exact pressing you are holding.

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

Search mode only. Discogs applies this order to the search itself, so it changes which results the record budget keeps. "Most wanted" and "Most collected" are the two orders collectors use to find the desirable pressings first.

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

Search mode only. Direction for the sort above. Ignored when Sort results by is set to best match.

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

URL mode only, ignored in search mode. Paste Discogs release, master, artist or label links (https://www.discogs.com/release/249504-... , /master/13814, /artist/72872, /label/895). Bare ids in the r249504 / m13814 / a72872 / l895 shorthand are accepted too, and a plain number is read as a release id.

## `urls` (type: `array`):

Alias for Catalogue links or ids, accepted under the name other Apify actors use for URL mode. Entries from both fields are read in order and de-duplicated.

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

Stop after this many records across the whole run. This is the run's cap. Use 0 for no limit, the run then stops when the searches run out of results.

## `maxPages` (type: `integer`):

Search mode only. Leave empty for no page limit, the run then stops at Max records or when Discogs runs out of results. Each page holds up to 100 records.

## `fetchDetails` (type: `boolean`):

Search mode: off by default, because search results already carry title, artist, year, country, format, labels, genres, styles, barcode and the have/want counts. Turn on to also read every result's full catalogue entry (tracklist, credits, images, videos, identifiers, matrix numbers, notes, rating) plus its live marketplace price. Each result read this way adds one Detail enrichment event. In URL mode the full record is always read, so this toggle changes nothing there and is never charged there.

## `priceStats` (type: `boolean`):

Off by default. The headline feature: instead of one pressing's lowest asking price, this walks the album's other pressings and returns the lowest, median, highest and average asking price across them, how many copies are for sale in total, and the want to have demand ratio for the whole album. Applies to releases and masters in both modes. Costs a handful of extra lookups per record and adds one Detail enrichment event.

## `maxPriceVersions` (type: `integer`):

Only used when Price statistics is on. How many of an album's pressings to ask the marketplace about, taken in descending order of how many collectors own them, so the sample follows the pressings with a live market. Higher values give a better distribution and cost more lookups per record.

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

Currency for every marketplace price and price statistic. Discogs converts from the seller's own currency.

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

Paste a previous run ID or dataset ID to continue a large pull without returning records already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring, for example to watch an album's price statistics move. The first run returns every matching record as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED records. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each keyword, entity kind, filter, sort and lookup setup; use State key to name or deliberately share a monitoring campaign.

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

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search, filter and lookup settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search: not when Max records capped it, not when Max result pages capped it, and not when Resume was used. This returns, and bills, extra rows.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page per record export; other connectors get a best effort write or digest. Leave empty to skip; never changes the dataset output.

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

URL or id of the Notion page under which record pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on records written to each connector per run. Does not affect the dataset.

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

Apify Proxy settings. The default works on every plan, including the free tier, and needs no configuration.

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

Optional and never required. Create a free token at Discogs, Settings, Developers. It lets large pulls finish faster, and it unlocks the per condition valuation fields (Mint through Poor) that Discogs shows only to a signed in member. Leave empty to run fully anonymously.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "nirvana nevermind"
  ],
  "searchType": "release",
  "sortBy": "relevance",
  "sortOrder": "desc",
  "startUrls": [
    "https://www.discogs.com/release/249504"
  ],
  "maxItems": 20,
  "fetchDetails": false,
  "priceStats": false,
  "maxPriceVersions": 5,
  "currency": "USD",
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "searchQueries": [
        "nirvana nevermind"
    ],
    "searchType": "release",
    "sortBy": "relevance",
    "sortOrder": "desc",
    "startUrls": [
        "https://www.discogs.com/release/249504"
    ],
    "maxItems": 20,
    "fetchDetails": false,
    "priceStats": false,
    "maxPriceVersions": 5,
    "currency": "USD",
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "mode": "search",
    "searchQueries": ["nirvana nevermind"],
    "searchType": "release",
    "sortBy": "relevance",
    "sortOrder": "desc",
    "startUrls": ["https://www.discogs.com/release/249504"],
    "maxItems": 20,
    "fetchDetails": False,
    "priceStats": False,
    "maxPriceVersions": 5,
    "currency": "USD",
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "mode": "search",
  "searchQueries": [
    "nirvana nevermind"
  ],
  "searchType": "release",
  "sortBy": "relevance",
  "sortOrder": "desc",
  "startUrls": [
    "https://www.discogs.com/release/249504"
  ],
  "maxItems": 20,
  "fetchDetails": false,
  "priceStats": false,
  "maxPriceVersions": 5,
  "currency": "USD",
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/discogs-scraper --silent --output-dataset

```

## MCP server setup

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