# Discogs Scraper (`solidcode/discogs-scraper`) Actor

\[💰 $3 / 1K] Extract releases, masters, artists, and labels from Discogs — catalog numbers, formats, barcodes, matrix/runout, tracklists, credits, plus marketplace price and have/want stats. Search by keyword or paste Discogs URLs; filter by genre, style, format, country, year, and label.

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

## Pricing

from $3.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.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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 Scraper

Pull the Discogs music database at scale — releases, masters, artists, and labels with catalog numbers, barcodes, matrix/runout etchings, tracklists, production credits, linked videos, marketplace pricing, and community have/want counts. Built for record dealers, vinyl collectors, discography researchers, and music-data teams who need a clean, structured pressing-level dataset without clicking through Discogs one release page at a time.

### Why This Scraper?

- **Four record types in one actor** — releases (a specific pressing), masters (every pressing of an album grouped), artists, and labels. Paste a Discogs URL of any of the four and it is recognised automatically, whatever else you have selected.
- **Matrix/runout and barcode etchings on each pressing's detail record** — the two identifiers dealers actually use to separate a first press from a 1987 reissue, split into their own clean fields instead of buried in one mixed list.
- **Catalog numbers straight from the label credits** — every catalog number Discogs lists for a release, joined per label, so you can match against your own inventory keys.
- **15 genres, 22 formats, 40 countries — all as pick-lists** — from Vinyl and Shellac (78 RPM) to Flexi-disc, Lathe Cut, and MiniDisc. Discogs uses its own country spellings ("UK", not "United Kingdom"), so the list saves you from silently empty runs.
- **Style filter for the sub-genre collectors actually shop by** — House, Techno, Shoegaze, Bebop, Death Metal. Far sharper than the 15 broad genres, and something most Discogs extractors simply don't offer.
- **Marketplace price and demand on the same row** — lowest asking price and number of copies for sale, alongside community have/want counts, so you can spot the pressings that are wanted far more than they're owned.
- **Sort by most collected or most wanted** — plus year (newest or oldest first) and title (A–Z or Z–A). Rank a whole genre or year by collector demand in one run.
- **Full details on by default** — tracklists, per-track production credits, release notes, linked videos, and estimated vinyl weight are collected automatically, with nothing to switch on.
- **No keyword required** — a filter on its own is a valid run. `genre: "Jazz"` with no search term browses the entire Jazz catalogue.

### Use Cases

**Record Dealing & Inventory**
- Identify exact pressings by matrix/runout etching or barcode before listing them
- Match catalog numbers against your own stock keys in bulk
- Compare lowest marketplace asking prices across formats and countries
- Spot high-demand pressings where want counts far exceed have counts

**Collection & Discography Research**
- Build a complete discography for an artist or label as structured rows
- Track every country variant of an album across its masters and pressings
- Pull full tracklists and production credits for liner-note research
- Follow sublabels and parent labels to map an imprint's family tree

**Music Market Analysis**
- Rank a genre or a release year by collector demand
- Compare vinyl, CD, and cassette availability across decades
- Measure how country of release affects marketplace pricing
- Track scarcity signals — copies for sale versus copies wanted

**Data Enrichment & Catalog Work**
- Enrich an existing music catalogue with barcodes and catalog numbers
- Resolve messy artist strings against canonical Discogs artist records
- Attach cover art and linked videos to your own release database
- Feed release metadata into recommendation and search systems

**Journalism & Content**
- Pull the pressing history behind an anniversary reissue
- Source verified label, year, and country data for reviews and features
- Build "most wanted records of 1979" style roundups from real demand data

### Getting Started

#### Search for an Artist

The simplest run — one search term, full details on by default:

```json
{
    "searchQueries": ["daft punk"],
    "maxItems": 20
}
````

#### Group Pressings by Album

Switch to masters to get one row per album rather than one per pressing:

```json
{
    "searchQueries": ["radiohead"],
    "resultType": "master",
    "sortBy": "wantDesc",
    "maxItems": 50
}
```

#### Browse a Whole Genre with No Keyword

Filters work on their own — no search term needed:

```json
{
    "resultType": "release",
    "genre": "Jazz",
    "style": "Bebop",
    "format": "Vinyl",
    "country": "US",
    "year": "1955-1965",
    "sortBy": "haveDesc",
    "maxItems": 200
}
```

#### Paste Discogs URLs Directly

Any release, master, artist, or label URL — each comes back with its full details:

```json
{
    "startUrls": [
        "https://www.discogs.com/release/249504-Rick-Astley-Never-Gonna-Give-You-Up",
        "https://www.discogs.com/artist/1289-Daft-Punk",
        "https://www.discogs.com/label/1-Planet-E"
    ]
}
```

#### Full-Featured Example

```json
{
    "searchQueries": ["blue note", "impulse"],
    "startUrls": ["https://www.discogs.com/master/13842-Kind-Of-Blue"],
    "resultType": "release",
    "maxItems": 500,
    "includeDetails": true,
    "genre": "Jazz",
    "format": "Vinyl",
    "country": "Japan",
    "label": "Blue Note",
    "year": "1970-1985",
    "sortBy": "yearAsc"
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["daft punk"]` | What to look for — an artist, an album, a label, or a catalog number. Each term is searched separately. Can be left empty if you use filters or URLs instead. |
| `startUrls` | string\[] | `[]` | Discogs release, master, artist, or label URLs to collect directly, no search needed. Each URL always returns its full details, and the URL's own kind of record wins over "What to Return". |
| `resultType` | select | `Releases — individual pressings` | The kind of record your search terms return: Releases (individual pressings), Masters (albums, all pressings grouped), Artists, or Labels. |
| `maxItems` | integer | `20` | How many records to collect per run (1–5,000). Results arrive in pages, so a number that isn't a round page size may return a few extra records rather than cutting a page short. |
| `includeDetails` | boolean | `true` | Adds the full tracklist, production credits, barcode and matrix/runout numbers, linked videos, and release notes to every record. Strongly recommended for artists and labels. On very large runs a few records may arrive without these extra fields. |

#### Filters

Every filter you leave empty simply widens the search.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `genre` | select | *(empty)* | One of 15 broad genres: Blues, Brass & Military, Children's, Classical, Electronic, Folk, World, & Country, Funk / Soul, Hip Hop, Jazz, Latin, Non-Music, Pop, Reggae, Rock, Stage & Screen. |
| `style` | string | *(empty)* | A precise sub-genre such as "House", "Techno", "Shoegaze", "Bebop", or "Death Metal". Must match a real Discogs style name exactly. |
| `format` | select | *(empty)* | One of 22 formats: Vinyl, CD, Cassette, Digital File, CDr, DVD, Box Set, Shellac (78 RPM), 8-Track Cartridge, All Media, VHS, Reel-To-Reel, Blu-ray, Acetate, SACD, Laserdisc, Hybrid, Flexi-disc, Lathe Cut, MiniDisc, Memory Stick, or Floppy Disk. |
| `country` | select | *(empty)* | The country a record was released in — 40 options including US, UK, Europe, Japan, Germany, UK & Europe, Worldwide, USSR, and German Democratic Republic (GDR). |
| `label` | string | *(empty)* | Only return records put out by this label, e.g. "Motown", "Blue Note", "Virgin". Must match a real Discogs label name. |
| `year` | string | *(empty)* | A single year (`"1998"`) or a range (`"2010-2015"`). |
| `sortBy` | select | `Relevance (Discogs default)` | Result order: Relevance, Year — newest first, Year — oldest first, Title — A to Z, Title — Z to A, Most collected, or Most wanted. |

### Output

Every record — release, master, artist, or label — comes back on the same flat row shape, with the fields that don't apply left empty. Fields marked **●** are filled only when **Include Full Details** is on (the default); everything else is present on every row. Here's a release with full details enabled:

```json
{
    "recordType": "release",
    "id": 249504,
    "url": "https://www.discogs.com/release/249504-Rick-Astley-Never-Gonna-Give-You-Up",
    "title": "Never Gonna Give You Up",
    "artistNames": "Rick Astley",
    "year": 1987,
    "released": "1987-07-27",
    "releasedFormatted": "27 Jul 1987",
    "country": "UK",
    "genres": ["Electronic", "Pop"],
    "styles": ["Synth-pop"],
    "labelNames": "RCA, PWL",
    "catalogNumber": "PB 41447",
    "formatNames": "Vinyl, 7\", 45 RPM, Single",
    "barcode": ["5012394144777"],
    "matrixRunout": ["PB-41447 A//1 R", "PB-41447 B//1 R"],
    "tracklist": [
        { "position": "A", "title": "Never Gonna Give You Up", "duration": "3:32" },
        { "position": "B", "title": "Never Gonna Give You Up (Instrumental)", "duration": "3:30" }
    ],
    "extraartists": [
        { "name": "Stock, Aitken & Waterman", "role": "Producer" }
    ],
    "videos": [
        { "uri": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "title": "Rick Astley - Never Gonna Give You Up" }
    ],
    "coverImage": "https://i.discogs.com/example/R-249504.jpeg",
    "numForSale": 214,
    "lowestPrice": 2.5,
    "have": 21456,
    "want": 4327,
    "estimatedWeight": 60,
    "notes": "Released in a generic RCA sleeve.",
    "masterId": 96559,
    "dataQuality": "Correct"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | `release`, `master`, `artist`, or `label` |
| `id` | number | Discogs identifier for the record |
| `url` | string | Direct Discogs page URL |
| `title` | string | Release/album title, or the artist or label name |
| `artists` ● | object\[] | Credited artists with their Discogs ids and join phrases |
| `artistNames` ● | string | Credited artists as one readable string |
| `year` | number | Release year (empty when Discogs doesn't state one) |
| `released` ● | string | Full release date where known |
| `releasedFormatted` ● | string | Human-readable release date, e.g. "27 Jul 1987" |
| `country` | string | Country of release, in Discogs' own spelling |
| `genres` | string\[] | Broad genres |
| `styles` | string\[] | Precise sub-genres |
| `notes` ● | string | Release notes as written by Discogs contributors |
| `dataQuality` ● | string | Discogs' own confidence rating for the entry |

#### Labels, Formats & Pressing Identifiers

| Field | Type | Description |
|-------|------|-------------|
| `labels` ● | object\[] | Labels with their catalog number and Discogs id |
| `labelNames` | string | Label names as one readable string |
| `catalogNumber` | string | Catalog number(s) for this pressing |
| `formats` ● | object\[] | Formats with quantity and descriptors (e.g. 45 RPM, Single) |
| `formatNames` | string | Formats as one readable string |
| `barcode` | string\[] | Barcode(s) printed on the sleeve |
| `matrixRunout` ● | string\[] | Matrix/runout codes etched into the dead wax |
| `identifiers` ● | object\[] | Every identifier Discogs holds, including rights society and pressing plant codes |
| `estimatedWeight` ● | number | Estimated vinyl weight in grams |

#### Tracklist, Credits & Media

Populated when **Include Full Details** is on.

| Field | Type | Description |
|-------|------|-------------|
| `tracklist` | object\[] | Every track with position, title, and duration |
| `extraartists` | object\[] | Production credits — producers, engineers, writers, players, with roles |
| `videos` | object\[] | Videos linked to the release, with title and description |
| `images` | object\[] | Full-size cover and sleeve images |
| `thumb` | string | Thumbnail image URL |
| `coverImage` | string | Primary cover image URL |

#### Marketplace & Community

| Field | Type | Description |
|-------|------|-------------|
| `numForSale` ● | number | Copies currently listed for sale |
| `lowestPrice` ● | number | Lowest asking price among those copies |
| `have` | number | People who own this record |
| `want` | number | People who want this record |

#### Artist & Label Profiles

Populated for `artist` and `label` records with **Include Full Details** on.

| Field | Type | Description |
|-------|------|-------------|
| `profile` | string | Biography or label history text |
| `urls` | string\[] | Official sites and social links |
| `members` | object\[] | Band members, with their own Discogs ids |
| `aliases` | object\[] | Other names the artist records under |
| `nameVariations` | string\[] | Spelling variants seen on sleeves |
| `sublabels` | object\[] | Imprints operating under this label |
| `parentLabel` | object | The label this one sits under |
| `contactInfo` | string | Published contact details for the label |

#### Linking Fields

| Field | Type | Description |
|-------|------|-------------|
| `masterId` | number | The master this pressing belongs to — join releases to albums |
| `mainRelease` ● | number | The release Discogs treats as the definitive one for a master |

### Tips for Best Results

- **Search by matrix/runout or catalog number to pin an exact pressing.** Type the dead-wax etching or catalog number straight into a search term — those strings are unique to one pressing, so they cut through the dozens of near-identical reissues a title search returns.
- **Pick Masters when you want albums, Releases when you want pressings.** A master is the album; a release is the specific vinyl or CD edition. Dealers almost always want releases; discography and chart work usually wants masters.
- **Keep Include Full Details on for artists and labels.** Without it, those records come back as little more than a name — no biography, no members, no sublabels.
- **Use Style rather than Genre when you can.** "Jazz" returns over a million records; "Bebop" returns the ones you meant. Style must match a real Discogs name exactly, so check the spelling on any Discogs release page.
- **Take the country from the list, never type it.** Discogs uses its own names — "UK" works, "United Kingdom" and "Great Britain" both return nothing at all.
- **Rank demand with Most wanted, then read the numbers.** Sort by Most wanted and compare `want` against `have` on each row — a high want-to-have ratio is the clearest scarcity signal on the site.
- **Have/want counts follow the search, not the paste.** Album (master) rows collected from a search term carry have/want counts; a master reached by pasting its URL won't have them. Search for the master instead if those counts matter.
- **Start with 20–50 results** to confirm the shape suits you, then raise the limit.

### Pricing

**From $3.00 per 1,000 results** — a full pressing-level record with tracklist, credits, identifiers, and marketplace stats, for less than a third of a cent. Bronze, Silver, and Gold are Apify's loyalty discount tiers; the table shows total cost at each.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is any record row in the output dataset — one release, master, artist, or label. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom integrations on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate music research, collection management, catalog enrichment, and record-trade analysis. It collects only publicly available catalogue data. Users are responsible for complying with applicable laws and Discogs' Terms of Service, and for respecting the licensing of Discogs' contributor-built database. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

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

What to look for on Discogs — an artist, an album, a label, or a catalog number. Add as many terms as you like; each one is searched separately. You can also leave this empty and use the filters below on their own to browse a whole genre or year.

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

Already have a page in mind? Paste Discogs release, master, artist, or label URLs here to scrape them directly, no search needed. Each URL always comes back with its full details, and the URL's own kind of record wins over the 'What to Return' setting below.

## `resultType` (type: `string`):

Choose the kind of record you want back from your search terms. 'Release' is a specific pressing (a particular vinyl or CD edition); 'Master' groups every pressing of the same album together. Artists and labels come back as profile records — turn on 'Include Full Details' to get anything beyond their name and picture.

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

How many records to collect per run. Higher numbers take longer and cost more. Results arrive in pages, so a run asking for a number that isn't a round page size may return a few extra records rather than cutting a page short.

## `includeDetails` (type: `boolean`):

Adds the full tracklist, production credits, barcode and matrix/runout numbers, linked videos, and release notes to every record. Strongly recommended for artists and labels — without it those come back as little more than a name. Turn it off for a faster, lighter run. On very large runs a small number of records may arrive without these extra fields.

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

Narrow results to one broad genre. Leave empty to include every genre.

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

A more precise sub-genre than the genre filter — for example 'House', 'Techno', 'Shoegaze', 'Bebop', or 'Death Metal'. Must match a real Discogs style name exactly; a typo or an invented style returns no results.

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

Limit results to one physical or digital format.

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

The country a record was released in. Pick from the list — Discogs uses its own country names, so typing something like 'United Kingdom' instead of 'UK' would return nothing.

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

Only return records put out by this label — for example 'Motown', 'Blue Note', or 'Virgin'. Must match a real Discogs label name; a misspelling returns no results.

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

A single year (e.g. 1998) or a range (e.g. 2010-2015). Leave empty to include every year.

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

Choose the order results come back in. Leave empty for Discogs' own relevance ranking.

## Actor input object example

```json
{
  "searchQueries": [
    "daft punk"
  ],
  "startUrls": [],
  "resultType": "release",
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

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

Key fields for every record — title, artist, year, country, format, label, catalog number, and marketplace price and have/want stats.

## `detail` (type: `string`):

Every field, including tracklists, production credits, barcode and matrix/runout identifiers, pressing plant, linked videos, and cover art.

# 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": [
        "daft punk"
    ],
    "startUrls": [],
    "resultType": "release",
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": ["daft punk"],
    "startUrls": [],
    "resultType": "release",
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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": [
    "daft punk"
  ],
  "startUrls": [],
  "resultType": "release",
  "maxItems": 20,
  "includeDetails": true
}' |
apify call solidcode/discogs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discogs Scraper",
        "description": "[💰 $3 / 1K] Extract releases, masters, artists, and labels from Discogs — catalog numbers, formats, barcodes, matrix/runout, tracklists, credits, plus marketplace price and have/want stats. Search by keyword or paste Discogs URLs; filter by genre, style, format, country, year, and label.",
        "version": "1.0",
        "x-build-id": "gf2qiNO1BeIbLmY5N"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~discogs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~discogs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~discogs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "What to look for on Discogs — an artist, an album, a label, or a catalog number. Add as many terms as you like; each one is searched separately. You can also leave this empty and use the filters below on their own to browse a whole genre or year.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Discogs URLs",
                        "type": "array",
                        "description": "Already have a page in mind? Paste Discogs release, master, artist, or label URLs here to scrape them directly, no search needed. Each URL always comes back with its full details, and the URL's own kind of record wins over the 'What to Return' setting below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultType": {
                        "title": "What to Return",
                        "enum": [
                            "release",
                            "master",
                            "artist",
                            "label"
                        ],
                        "type": "string",
                        "description": "Choose the kind of record you want back from your search terms. 'Release' is a specific pressing (a particular vinyl or CD edition); 'Master' groups every pressing of the same album together. Artists and labels come back as profile records — turn on 'Include Full Details' to get anything beyond their name and picture."
                    },
                    "maxItems": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many records to collect per run. Higher numbers take longer and cost more. Results arrive in pages, so a run asking for a number that isn't a round page size may return a few extra records rather than cutting a page short."
                    },
                    "includeDetails": {
                        "title": "Include Full Details",
                        "type": "boolean",
                        "description": "Adds the full tracklist, production credits, barcode and matrix/runout numbers, linked videos, and release notes to every record. Strongly recommended for artists and labels — without it those come back as little more than a name. Turn it off for a faster, lighter run. On very large runs a small number of records may arrive without these extra fields."
                    },
                    "genre": {
                        "title": "Genre",
                        "enum": [
                            "Blues",
                            "Brass & Military",
                            "Children's",
                            "Classical",
                            "Electronic",
                            "Folk, World, & Country",
                            "Funk / Soul",
                            "Hip Hop",
                            "Jazz",
                            "Latin",
                            "Non-Music",
                            "Pop",
                            "Reggae",
                            "Rock",
                            "Stage & Screen"
                        ],
                        "type": "string",
                        "description": "Narrow results to one broad genre. Leave empty to include every genre."
                    },
                    "style": {
                        "title": "Style",
                        "type": "string",
                        "description": "A more precise sub-genre than the genre filter — for example 'House', 'Techno', 'Shoegaze', 'Bebop', or 'Death Metal'. Must match a real Discogs style name exactly; a typo or an invented style returns no results."
                    },
                    "format": {
                        "title": "Format",
                        "enum": [
                            "Vinyl",
                            "CD",
                            "Cassette",
                            "File",
                            "CDr",
                            "DVD",
                            "Box Set",
                            "Shellac",
                            "8-Track Cartridge",
                            "All Media",
                            "VHS",
                            "Reel-To-Reel",
                            "Blu-ray",
                            "Acetate",
                            "SACD",
                            "Laserdisc",
                            "Hybrid",
                            "Flexi-disc",
                            "Lathe Cut",
                            "Minidisc",
                            "Memory Stick",
                            "Floppy Disk"
                        ],
                        "type": "string",
                        "description": "Limit results to one physical or digital format."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "UK",
                            "Europe",
                            "Japan",
                            "Germany",
                            "Canada",
                            "Australia",
                            "France",
                            "Italy",
                            "Netherlands",
                            "Russia",
                            "Spain",
                            "Brazil",
                            "Poland",
                            "South Africa",
                            "Sweden",
                            "New Zealand",
                            "UK & Europe",
                            "Belgium",
                            "Worldwide",
                            "Greece",
                            "Mexico",
                            "Argentina",
                            "Switzerland",
                            "Finland",
                            "Denmark",
                            "South Korea",
                            "Portugal",
                            "Ireland",
                            "Austria",
                            "Norway",
                            "Israel",
                            "Yugoslavia",
                            "Czech Republic",
                            "Turkey",
                            "India",
                            "Hungary",
                            "USSR",
                            "German Democratic Republic (GDR)",
                            "Unknown"
                        ],
                        "type": "string",
                        "description": "The country a record was released in. Pick from the list — Discogs uses its own country names, so typing something like 'United Kingdom' instead of 'UK' would return nothing."
                    },
                    "label": {
                        "title": "Record Label",
                        "type": "string",
                        "description": "Only return records put out by this label — for example 'Motown', 'Blue Note', or 'Virgin'. Must match a real Discogs label name; a misspelling returns no results."
                    },
                    "year": {
                        "title": "Release Year",
                        "type": "string",
                        "description": "A single year (e.g. 1998) or a range (e.g. 2010-2015). Leave empty to include every year."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "yearDesc",
                            "yearAsc",
                            "titleAsc",
                            "titleDesc",
                            "haveDesc",
                            "wantDesc"
                        ],
                        "type": "string",
                        "description": "Choose the order results come back in. Leave empty for Discogs' own relevance ranking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
