# Discogs Scraper · Releases, Artists, Labels & Marketplace (`reapx/discogs-scraper`) Actor

Discogs Scraper (Discogs.com scraper) to scrape vinyl records, CDs, music releases, artists, and labels. Extract marketplace prices, collector demand, formats, barcodes, and tracklists into CSV or JSON.

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

## Pricing

from $2.10 / 1,000 release returneds

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/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

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## Discogs Scraper · Releases, Artists, Labels & Marketplace

**Discogs Scraper** (Discogs.com scraper) extracts vinyl records, CDs, music releases, artists, labels, and marketplace data from Discogs. Search Discogs by keyword, artist, label, genre, style, year, or format and export structured datasets to JSON, CSV, or Excel.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is
> inferred, modelled or filled in, and a field absent from the source is absent from the row.
> The extracted archive for this source is browsable at
> [reapx.dev/data/discogs-scraper/](https://reapx.dev/data/discogs-scraper/) and mirrored as an open dataset on
> [Hugging Face](https://huggingface.co/datasets/reapxdev/discogs-scraper) and
> [Kaggle](https://www.kaggle.com/datasets/reapxdev/discogs-scraper). Questions: reapxdev@proton.me

Extract release titles, catalogue numbers, formats, barcodes, tracklists, plus live Discogs marketplace prices, seller stats, collector have/want counts, and ratings. Fast HTTP scraper with no login or API key required.

### Discogs Scraper features

- **Discogs Music Database & Vinyl Scraper**: Extract release details, master releases, discographies, and catalogue numbers.
- **Discogs Marketplace & Price Mining**: Get live lowest price, number of items for sale, and collector demand metrics (have vs want counts).
- **Zero Setup**: Reads Discogs public endpoints directly over HTTP with fast execution and minimal compute cost.

### What you get per release

| Field | |
|---|---|
| `handle` · `artistName` · `artistId` · `artistUrl` | who made it |
| `releaseId` · `releaseTitle` · `year` · `released` · `country` | which pressing |
| `labels` · `catalogNumbers` · `formats` | how it was issued |
| `genres` · `styles` · `trackCount` · `masterId` | what it is |
| `communityHave` · `communityWant` | ownership and demand |
| `ratingAverage` · `ratingCount` | how it is rated |
| `numForSale` · `lowestPriceUsd` | the live marketplace |
| `dataQuality` · `releaseUrl` · `retrievedAt` | |

### Price a record collection

Search by artist, label or catalogue number and read `numForSale` with `lowestPriceUsd`.
Both are read live from the Discogs marketplace during the run, so a scheduled daily run
gives you a price series per `releaseId` with no manual checking.

### Find what collectors want and cannot get

`communityWant` divided by `communityHave` is the ratio the community reads as demand. Pull
a genre or a label's catalogue, sort on it, and the scarce pressings surface without any
invented scoring.

### Pull a whole discography or label catalogue

Put numeric Discogs ids into **Discogs artist ids** or **Discogs label ids** - the number in
a `discogs.com/artist/…` or `discogs.com/label/…` URL - and the run returns every release
under them instead of searching.

### Rate limiting, honestly

Discogs allows **25 requests a minute** to an anonymous caller. This actor is paced under
that ceiling and the setting is capped there, so a large run is slow by design rather than
throttled halfway through. Turning off **Include marketplace and rating data** drops it to
one request per hundred releases when you only need the catalogue.

### Input configuration

Every field is optional. The prefilled values below are what runs if you press Start without changing anything.

#### What to search

Combine any of these. Leave them all empty to list Electronic releases.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `query` | string | free text | Free text matched across artist, release title, label and catalogue number. |
| `genre` | string | free text | A Discogs top-level genre - Electronic, Rock, Jazz, Hip Hop, Funk / Soul, Classical, Reggae, Pop, Folk, World, & Country, Latin, Blues, Non-Music, Stage & Screen, Brass & Military, Children's. Prefilled with `"Electronic"`. |
| `style` | string | free text | A Discogs style, which is finer than a genre - Techno, House, Ambient, Drum n Bass, Hard Bop, Shoegaze, Bossa Nova. |
| `label` | string | free text | Restrict to one record label by name, for example Warp Records, Blue Note, Motown. |
| `country` | string | free text | Country of release, for example UK, US, Germany, Japan. |
| `format` | string | free text | Physical or digital format - Vinyl, CD, Cassette, File, Box Set. |
| `year` | string | free text | A single release year, for example 1994. |

#### Or pull a whole discography or catalogue

Given here, these replace the search above.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `artistIds` | list | one value per line | Pull complete discographies instead of searching. One numeric Discogs artist id per line - the number in a discogs.com/artist/ URL. |
| `labelIds` | list | one value per line | One numeric Discogs label id per line - the number in a discogs.com/label/ URL. Returns that label's whole catalogue. |

#### Filters

Applied after each release is read. Both need marketplace data, below.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `minCommunityHave` | integer | 0 to 1000000 | Keep only releases at least this many Discogs users have in their collection - the simplest measure of how widely a pressing circulated. |
| `minForSale` | integer | 0 to 100000 | Keep only releases with at least this many copies currently listed in the Discogs marketplace. |

#### Output

Row depth, volume and politeness.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `includeMarketData` | true/false | checkbox | Read each release's full record for copies for sale, lowest price, star rating, tracklist and exact release date. Turn off for a faster, shallower run - the artist, label and catalogue number still come back. Prefilled with `true`. |
| `maxReleases` | integer | 1 to 2000 | Hard ceiling on the rows this run produces, and therefore on what it costs. You are charged per release returned. Prefilled with `25`. |
| `requestsPerMinute` | integer | 1 to 25 | Discogs allows 25 requests a minute to an anonymous caller and this is capped there. Lower it if you see the API refusing requests. Prefilled with `22`. |

### Pricing

Pay per event. The primary event is **Release returned** (`release-returned`), charged at **$0.003 per event** on the free plan, falling to $0.0015 on the highest tier.

One Discogs release delivered as a complete row, including artist, label, catalogue number, collector counts and live marketplace figures. Blocked sources and empty result sets are never charged.

Other charged events: `apify-actor-start` (Actor Start).

Minimum charge cap per run: $0.05.

Tiered discounts apply automatically on every paid Apify plan. Platform usage is absorbed by the Actor, so the per-event price is the whole price.

### Usage examples

#### The prefilled run, which is what Start does with nothing changed

```json
{
  "genre": "Electronic",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22
}
```

#### Filter by search query

```json
{
  "genre": "Electronic",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22,
  "query": "Aphex Twin"
}
```

#### Filter by genre

```json
{
  "genre": "Jazz",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22
}
```

#### Filter by style

```json
{
  "genre": "Electronic",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22,
  "style": "Techno"
}
```

#### Filter by label name

```json
{
  "genre": "Electronic",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22,
  "label": "Warp Records"
}
```

### Output example

One row, exactly as the actor wrote it to the dataset:

```json
{
  "handle": "Doon Kanda",
  "artistName": "Doon Kanda",
  "artistId": 5512216,
  "artistUrl": "https://www.discogs.com/artist/5512216",
  "releaseId": "12421524",
  "releaseTitle": "Luna EP",
  "year": 2018,
  "released": "2018-08-24",
  "country": "Europe",
  "genres": [
    "Electronic"
  ],
  "styles": [
    "Experimental",
    "IDM"
  ],
  "labels": [
    "Hyperdub"
  ],
  "catalogNumbers": [
    "HDB116"
  ],
  "formats": [
    "Vinyl"
  ],
  "trackCount": 7,
  "masterId": "1589103",
  "communityHave": 304,
  "communityWant": 146
}
```

That row carries 25 fields in total; 18 are shown.

#### Fields on every row

| Field | Type | What it is |
| --- | --- | --- |
| `handle` | string | The release's primary artist, exactly as Discogs names them. Discogs disambiguates acts that share a name with a numeric suffix, so this addresses one act uniquely and is stable across runs. |
| `artistName` | string | The primary credited artist on the release. |
| `artistId` | integer | The artist's numeric id, usable to pull their whole discography. |
| `artistUrl` | string | The artist's public page on discogs.com. |
| `releaseId` | string | The release's permanent numeric id on Discogs. |
| `releaseTitle` | string | The title of this particular pressing. |
| `year` | integer | The year this pressing was released. |
| `released` | string | The exact release date where Discogs records one. |
| `country` | string | Where this pressing was released. |
| `genres` | list | Discogs' top-level genres for the release. |
| `styles` | list | Discogs' finer style tags for the release. |
| `labels` | list | Every label credited on this pressing. |
| `catalogNumbers` | list | The label catalogue numbers printed on this pressing. |
| `formats` | list | The physical or digital formats this pressing came in. |
| `trackCount` | integer | How many tracks the release's tracklist holds. |
| `masterId` | string | The id of the master record grouping every pressing of this work, where one exists. |
| `communityHave` | integer | How many Discogs users have this pressing in their collection. |
| `communityWant` | integer | How many Discogs users have this pressing on their wantlist. The want-to-have ratio is the field collectors read as demand. |
| `ratingAverage` | number | Average user rating out of 5. |
| `ratingCount` | integer | How many users rated this pressing. |
| `numForSale` | integer | How many copies are listed in the Discogs marketplace right now. |
| `lowestPriceUsd` | number | The cheapest copy currently listed in the marketplace. |
| `dataQuality` | string | Discogs' own label for how well vetted this entry is. |
| `releaseUrl` | string | The release's public page on discogs.com. |
| `retrievedAt` | string | When this row was read from Discogs, in UTC. |

3 named dataset views ship with it: **Releases**, **Marketplace**, **Catalogue**. They drive the Output tab in Console and the Output block on the Actor's `.md` page.

### FAQ

**Does it need a Discogs account or token?** No. Every endpoint it uses answers an
unauthenticated caller that sends a User-Agent.

**Why is `handle` the artist and not the release?** Because it is what addresses a stable
thing across runs. Discogs disambiguates two acts of the same name itself, so the artist
name identifies one act, and grouping releases under it is how a discography reads.

**What is the difference between a release and a master?** A master groups every pressing
of one work; a release is one pressing, with its own country, format, catalogue number and
marketplace. This returns releases, and carries `masterId` so you can group them yourself.

**Are the marketplace figures live?** Yes - `numForSale` and `lowestPriceUsd` are read from
the release record during the run and change through the day.

***

Unofficial - not affiliated with Discogs. Collects public data only. reapx.
Contact reapxdev@proton.me.

### The full published archive

- **[discogs scraper archive](https://reapx.dev/data/discogs-scraper/)** — every entity this Actor has observed
- **[All reapx datasets](https://reapx.dev/data/)** — 20 sources, tens of thousands of pages
- **[llms.txt](https://reapx.dev/llms.txt)** · **[feed.json](https://reapx.dev/feed.json)** ·
  **[feed.xml](https://reapx.dev/feed.xml)** — the machine-readable index, for agents

Each archive page carries Dataset JSON-LD, a canonical URL and the identifiers used, so an agent
can resolve an entity without running anything. Nothing on those pages is estimated or modelled.

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "label": "Warp Records",
  "includeMarketData": true,
  "requestsPerMinute": 22,
  "maxReleases": 200
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "handle": "Prefuse 73",
  "artistName": "Prefuse 73",
  "artistId": 3722,
  "artistUrl": "https://www.discogs.com/artist/3722",
  "releaseId": "10326565",
  "releaseTitle": "Vocal Studies + Uprock Narratives",
  "year": 2001,
  "released": "2001",
  "country": "US",
  "genres": [
    "Electronic",
    "Hip Hop"
  ],
  "styles": [
    "Glitch",
    "Breaks",
    "IDM",
    "Downtempo",
    "Experimental",
    "Glitch Hop"
  ],
  "labels": [
    "Warp Records"
  ],
  "catalogNumbers": [
    "WARP ADVCD 83",
    "warp advcd 83"
  ],
  "formats": [
    "CD"
  ],
  "trackCount": 16,
  "masterId": "51105",
  "communityHave": 7,
  "communityWant": 38,
  "ratingAverage": 0,
  "ratingCount": 0,
  "numForSale": 3,
  "lowestPriceUsd": 5.5,
  "dataQuality": "Needs Vote",
  "releaseUrl": "https://www.discogs.com/release/10326565",
  "retrievedAt": "2026-08-03T12:32:06Z"
}
```

### How it works

1. You set the filters below, or none at all - every field is optional.
2. The Actor calls the public **api.discogs.com** API directly over HTTP. There is no key to obtain, no login and no headless browser, so a run is fast and cannot break on a UI change.
3. It pages through the results at the rate the source asks for, honouring `Retry-After` rather than retrying into a harder block.
4. Every row is pushed to the dataset **as it is built** - never buffered to the end. A run that hits its time limit still returns everything it collected.
5. You are charged `release-returned` at **$0.003 per row**, and nothing for Apify platform usage. The maximum-results field is therefore your cost cap, and Apify Store discounts apply on top.

### 💬 Your feedback

Found a bug, or need a field this does not return yet? Open an issue on the Actor's **Issues**
tab, or write to **reapxdev@proton.me**. Bugs get fixed and reasonable field requests get
added.

### ⚠️ Run outcomes and error handling

This Actor reports what happened in the run's **status message**, and it always keeps whatever it collected. These are the outcomes you can get and what each one means.

| Outcome | What it means |
|---|---|
| **Success** | Rows were returned and you were charged `release-returned` at $0.003 per row. |
| **No matches** | The source returned nothing for your filters. **Nothing is charged.** Widen the date window or drop a filter. |
| **Partial - time limit** | The run reached its time limit. It stops collecting about 45 seconds early, pushes what it has and finishes **SUCCEEDED** with a status message saying how far it got. The dataset is correct as far as it went; it is never truncated silently. |
| **Partial - source refused** | The source rate-limited or refused some requests. The affected items are skipped and named in the log, and **everything already collected is still pushed**. A block never discards a run's work. |

#### What is guaranteed either way

- **Every row is pushed as it is built**, not buffered to the end of the run. Anything that buffers output loses everything to a timeout, a block or a migration; this does not.
- **`Retry-After` is respected.** When the source asks for a pause, the Actor waits the time it asked for instead of retrying into a harder block.
- **Requests go through Apify's datacenter proxy group**, so concurrent runs do not share a single egress IP.
- **A field absent from the source is absent from the row.** Nothing is inferred, modelled or filled in to make a row look complete.

### 🧭 Ready-made configurations

These are saved, published configurations of this exact Actor. Open one and run it as it is, or copy its input as a starting point - each link is a live page with the full input and its output schema.

| Configuration | Input |
|---|---|
| [Techno Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-techno-releases) | `genre`: Electronic; `style`: Techno; `requestsPerMinute`: 22 |
| [House Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-house-releases) | `genre`: Electronic; `style`: House; `requestsPerMinute`: 22 |
| [Ambient Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-ambient-releases) | `genre`: Electronic; `style`: Ambient; `requestsPerMinute`: 22 |
| [Drum & Bass Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-drum-n-bass-releases) | `genre`: Electronic; `style`: Drum n Bass; `requestsPerMinute`: 22 |
| [IDM Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-idm-releases) | `genre`: Electronic; `style`: IDM; `requestsPerMinute`: 22 |
| [Synth-Pop Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-synth-pop-releases) | `genre`: Electronic; `style`: Synth-pop; `requestsPerMinute`: 22 |
| [Punk Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-punk-releases) | `genre`: Rock; `style`: Punk; `requestsPerMinute`: 22 |
| [Prog Rock Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-prog-rock-releases) | `genre`: Rock; `style`: Prog Rock; `requestsPerMinute`: 22 |
| [Shoegaze Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-shoegaze-releases) | `genre`: Rock; `style`: Shoegaze; `requestsPerMinute`: 22 |
| [Psychedelic Rock Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-psychedelic-rock-releases) | `genre`: Rock; `style`: Psychedelic Rock; `requestsPerMinute`: 22 |
| [Hard Bop Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-hard-bop-releases) | - |
| [Free Jazz Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-free-jazz-releases) | - |
| [Boom Bap Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-boom-bap-releases) | - |
| [Disco Releases on Discogs - Prices & Rarity](https://apify.com/reapx/discogs-scraper/examples/discogs-disco-releases) | - |

There are **50** of these in total, all listed on the Actor's [**Examples** tab](https://apify.com/reapx/discogs-scraper).

# Actor input Schema

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

Free text matched across artist, release title, label and catalogue number.<br><br>Leave this field empty to skip this filter.

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

A Discogs top-level genre - Electronic, Rock, Jazz, Hip Hop, Funk / Soul, Classical, Reggae, Pop, Folk, World, & Country, Latin, Blues, Non-Music, Stage & Screen, Brass & Military, Children's.<br><br>Leave this field empty to skip this filter.

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

A Discogs style, which is finer than a genre - Techno, House, Ambient, Drum n Bass, Hard Bop, Shoegaze, Bossa Nova.<br><br>Leave this field empty to skip this filter.

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

Restrict to one record label by name, for example Warp Records, Blue Note, Motown.<br><br>Leave this field empty to skip this filter.

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

Country of release, for example UK, US, Germany, Japan.<br><br>Leave this field empty to skip this filter.

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

Physical or digital format - Vinyl, CD, Cassette, File, Box Set.<br><br>Leave this field empty to skip this filter.

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

A single release year, for example 1994.<br><br>Leave this field empty to skip this filter.

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

Pull complete discographies instead of searching. One numeric Discogs artist id per line - the number in a discogs.com/artist/ URL.<br><br>Leave this field empty to include every option.

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

One numeric Discogs label id per line - the number in a discogs.com/label/ URL. Returns that label's whole catalogue.<br><br>Leave this field empty to include every option.

## `minCommunityHave` (type: `integer`):

Keep only releases at least this many Discogs users have in their collection - the simplest measure of how widely a pressing circulated.

## `minForSale` (type: `integer`):

Keep only releases with at least this many copies currently listed in the Discogs marketplace.

## `includeMarketData` (type: `boolean`):

Read each release's full record for copies for sale, lowest price, star rating, tracklist and exact release date. Turn off for a faster, shallower run - the artist, label and catalogue number still come back.

## `maxReleases` (type: `integer`):

Hard ceiling on the rows this run produces, and therefore on what it costs. You are charged per release returned.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `requestsPerMinute` (type: `integer`):

Discogs allows 25 requests a minute to an anonymous caller and this is capped there. Lower it if you see the API refusing requests.

## Actor input object example

```json
{
  "query": "Aphex Twin",
  "genre": "Jazz",
  "style": "Techno",
  "label": "Warp Records",
  "country": "Germany",
  "format": "Vinyl",
  "year": "1994",
  "artistIds": [
    "72872",
    "125246"
  ],
  "labelIds": [
    "23528"
  ],
  "minCommunityHave": 500,
  "minForSale": 5,
  "includeMarketData": true,
  "maxReleases": 200,
  "requestsPerMinute": 22
}
```

# Actor output Schema

## `overview` (type: `string`):

The overview view of this run's dataset.

## `marketplace` (type: `string`):

The marketplace view of this run's dataset.

## `catalogue` (type: `string`):

The catalogue view of this run's dataset.

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

Every record this run produced, with all fields and no view applied. Field-level titles, types, descriptions and examples are declared in the dataset schema.

# 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 = {
    "genre": "Electronic",
    "includeMarketData": true,
    "maxReleases": 25,
    "requestsPerMinute": 22
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/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 = {
    "genre": "Electronic",
    "includeMarketData": True,
    "maxReleases": 25,
    "requestsPerMinute": 22,
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/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 '{
  "genre": "Electronic",
  "includeMarketData": true,
  "maxReleases": 25,
  "requestsPerMinute": 22
}' |
apify call reapx/discogs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ifFo9iB1E9AAzHail/builds/OPNdkVePQD3RJMG3a/openapi.json