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

Scrape music releases, artists, and labels from Discogs. Get album titles, artists, years, genres, styles, formats, countries, tracklists, and community have/want stats for millions of records. Filter by type, year, country, genre, style, and format.

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

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎵 Discogs Music Releases Scraper

> 🚀 **Export music release data from Discogs in seconds.** Search **8,000,000+ releases, masters, artists, and labels** by keyword, genre, or type. No API key, no registration, no manual browsing.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **🎵 8,000,000+ releases** · **🌍 Worldwide coverage** · **🎸 Any genre or style**

The **Discogs Music Releases Scraper** queries the Discogs public REST API and returns **12 fields per record**, including image, artist, label, year, genre tags, style tags, format, country of release, and a direct link to the Discogs page. Discogs is the world's most comprehensive music database, maintained by millions of collectors, record store owners, and audiophiles since 2000.

The catalog covers every genre, format, country, and decade. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes - no parser engineering, no account setup, no rate-limit wrestling.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Music researchers, record store owners, streaming analysts, catalog managers, discographers, collectors, data journalists | Catalog enrichment, release tracking, price research, genre analysis, artist discography export, playlist curation data |

---

### 📋 What the Discogs Music Releases Scraper does

Four search workflows in a single run:

- 🔍 **Keyword search.** Find releases, masters, artists, or labels by any keyword - artist name, album title, catalog number.
- 🎸 **Genre filter.** Narrow results to Rock, Jazz, Electronic, Hip Hop, Classical, Folk, or any other genre Discogs recognizes.
- 📀 **Type filter.** Choose between Release (specific pressing), Master Release (canonical entry), Artist, or Label.
- 📦 **Bulk export.** Collect up to 1,000,000 records per run with automatic pagination and respectful rate limiting.

Each record includes thumbnail image, full title, artist name, label, release year, genre tags, style subtags, format tags, country, and a direct URL to the Discogs page.

> 💡 **Why it matters:** building a music catalog feed from scratch means dealing with inconsistent tags, inconsistent artist names, and stale data. Discogs has already done that normalization work across 26 years of community curation. This Actor gives you the clean output without the infrastructure.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded music dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>search</td><td>string</td><td>"nirvana"</td><td>Keyword to search on Discogs (artist name, album title, label name, etc.).</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>type</td><td>string</td><td>"release"</td><td>Search type: release, master, artist, or label.</td></tr>
<tr><td>genre</td><td>string</td><td><em>empty</em></td><td>Optional genre filter (e.g. "Rock", "Jazz", "Electronic").</td></tr>
</tbody>
</table>

**Example: 50 Nirvana releases on Discogs.**

```json
{
    "search": "nirvana",
    "type": "release",
    "maxItems": 50
}
````

**Example: 100 Jazz master releases.**

```json
{
    "search": "miles davis",
    "type": "master",
    "genre": "Jazz",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Discogs applies rate limits to unauthenticated API access (25 requests per minute). The Actor automatically paginates and waits between requests to stay within limits. For large exports (1,000+ items), plan for 2-4 minutes per 100 records due to the image-fetching step that resolves thumbnail URLs.

***

### 📊 Output

Each music release record contains **12 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | `"https://i.discogs.com/..."` |
| 🏷️ `title` | string | `"Nirvana - Nevermind"` |
| 🎤 `artist` | string | `"Nirvana"` |
| 🏢 `label` | string | `"DGC Records"` |
| 📅 `year` | string | `"1991"` |
| 🎸 `genre` | array | `["Rock"]` |
| 🎵 `style` | array | `["Grunge", "Alternative Rock"]` |
| 💿 `format` | array | `["Vinyl", "LP"]` |
| 🌍 `country` | string | `"US"` |
| 🔗 `url` | string | `"https://www.discogs.com/release/..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-21T23:46:48.000Z"` |
| ❌ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>💿 Vinyl reissue: Nirvana - Self-titled (DGC, 2015, Europe)</strong></summary>

```json
{
    "imageUrl": "https://i.discogs.com/w7JTNpEghFbtBxIFIgn8twjuiQlzqCCs6TQ3NRKKlzc/rs:fit/g:sm/q:40/h:150/w:150/czM6Ly9kaXNjb2dz/LWRhdGFiYXNlLWlt/YWdlcy9SLTc0NDU5/NjEtMTcwNzI0NzI1/NC0zNTIzLmpwZWc.jpeg",
    "title": "Nirvana - Nirvana",
    "artist": "Nirvana",
    "label": "DGC",
    "year": "2015",
    "genre": ["Rock"],
    "style": ["Grunge", "Alternative Rock"],
    "format": ["Vinyl", "LP", "Compilation", "Reissue"],
    "country": "Europe",
    "url": "https://www.discogs.com/release/7445961-Nirvana-Nirvana",
    "scrapedAt": "2026-05-21T23:46:48.229Z",
    "error": null
}
```

</details>

<details>
<summary><strong>💿 CD compilation: Nirvana - Self-titled (Geffen, 2002, Europe)</strong></summary>

```json
{
    "imageUrl": "https://i.discogs.com/frCC75Kl8L6RqocuaGDcy3i51cJdV_43jvpTOC-p6kA/rs:fit/g:sm/q:40/h:150/w:150/czM6Ly9kaXNjb2dz/LWRhdGFiYXNlLWlt/YWdlcy9SLTUzMjI0/MDYtMTQ2MjUzMDg3/NC00OTIwLnBuZw.jpeg",
    "title": "Nirvana - Nirvana",
    "artist": "Nirvana",
    "label": "Geffen Records",
    "year": "2002",
    "genre": ["Rock"],
    "style": ["Grunge", "Alternative Rock"],
    "format": ["CD", "Compilation", "Remastered"],
    "country": "Europe",
    "url": "https://www.discogs.com/release/5322406-Nirvana-Nirvana",
    "scrapedAt": "2026-05-21T23:47:02.800Z",
    "error": null
}
```

</details>

<details>
<summary><strong>💿 Limited Edition vinyl: Nirvana - Self-titled (DGC, 2020, US)</strong></summary>

```json
{
    "imageUrl": "https://i.discogs.com/e6O5lXo7d7hBzG72dE0Pi3qOkjlW6gUHBw7quConFAs/rs:fit/g:sm/q:40/h:150/w:150/czM6Ly9kaXNjb2dz/LWRhdGFiYXNlLWlt/YWdlcy9SLTE2MjA4/OTA0LTE2OTkxNTU1/OTEtNjc3My5qcGVn.jpeg",
    "title": "Nirvana - Nirvana",
    "artist": "Nirvana",
    "label": "DGC",
    "year": "2020",
    "genre": ["Rock"],
    "style": ["Alternative Rock", "Grunge", "Acoustic"],
    "format": ["Vinyl", "LP", "Compilation", "Limited Edition", "Reissue"],
    "country": "US",
    "url": "https://www.discogs.com/release/16208904-Nirvana-Nirvana",
    "scrapedAt": "2026-05-21T23:46:55.304Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **Comprehensive catalog.** 8,000,000+ releases, masters, artists, and labels across every genre, format, and country. |
| 🖼️ | **Thumbnail images included.** Every record fetches the official Discogs artwork URL - ready for visual UIs and catalogs. |
| 🎸 | **Genre and style tags.** Multi-level taxonomy (genre + style subtags) enables precise music analysis and filtering. |
| ⚡ | **Fast for small runs.** 10 releases in under 30 seconds on any plan. |
| 🌐 | **No auth required.** Works entirely on the public Discogs API. No tokens, no login, no account. |
| 🔁 | **Always live.** Every run fetches current data - reflects the latest community additions and corrections. |
| 📦 | **Bulk-ready.** Automatic pagination handles arbitrarily large queries up to 1,000,000 records. |

> 📊 Discogs is cited by vinyl collectors, streaming platforms, and musicologists as the reference database for physical media metadata.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Images | Rate limits | Setup |
|---|---|---|---|---|---|
| **⭐ Discogs Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **8M+ releases** worldwide | **Yes** | Handled automatically | ⚡ 2 min |
| Discogs API (manual) | Free (rate-limited) | Full | Manual fetch | 25 req/min, no retry logic | 🐢 Hours |
| MusicBrainz API | Free | 2M releases | No | Per-endpoint limits | 🕒 Hours |
| Manual browsing | Free | Unlimited | Screen only | None | 🐢 Days |
| Paid music data vendors | $500+/month | Variable | Usually yes | None | ⏳ Days |

Pick this Actor when you need structured Discogs data with images, automatic pagination, and zero infrastructure overhead.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Discogs Music Releases Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a search keyword, choose a type, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your music data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎵 Music Catalogs & Streaming

- Enrich internal catalogs with genre, style, and label metadata
- Build artist discography pages from Discogs data
- Deduplicate and normalize release entries across formats
- Feed recommendation engines with multi-level genre tags

</td>
<td width="50%" valign="top">

#### 🛒 Record Stores & Marketplace

- Sync physical inventory descriptions with Discogs release data
- Identify rare pressings by country, year, and format
- Monitor which releases are catalogued as Limited Edition or Reissue
- Build product pages with artwork thumbnails included

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Music Research & Journalism

- Trace how many pressings a landmark album received over time
- Compare label activity across decades and countries
- Build genre-trend datasets for music industry reporting
- Cross-reference Discogs catalog with streaming API data

</td>
<td width="50%" valign="top">

#### 🤖 Data Engineering & ML

- Training sets for music genre classifiers
- Album cover image datasets via thumbnail URLs
- Time-series datasets of release activity by artist or label
- Reference corpora for entity resolution and deduplication

</td>
</tr>
</table>

***

### 🔌 Automating Discogs Music Releases Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Weekly refreshes keep music catalog databases in sync with the latest Discogs additions automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Music sociology studies on genre evolution and geographic spread
- Digital humanities projects mapping global recorded-music output
- Reproducible datasets for musicology theses and papers
- Cross-decade studies on album format shifts (LP to CD to vinyl revival)

</td>
<td width="50%">

#### 🎨 Personal and creative

- Build a personal discography database for your record collection
- Create "albums by decade" visualizations for social media
- Power a vinyl-hunting app with release-type and country filters
- Feed a music blog with structured metadata and cover art

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Preserve and document local music scenes through catalog data
- Support music archives and libraries with structured metadata
- Document independent label output for cultural preservation
- Research gender and geographic representation in recorded music

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype music recommendation algorithms with genre + style signals
- Validate hypotheses about niche genre crossovers
- Test album-cover visual classifiers with Discogs image URLs
- Explore label ecosystems and artist-label relationships

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Discogs%20Music%20Releases%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Discogs%20Music%20Releases%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Discogs%20Music%20Releases%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Discogs%20Music%20Releases%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter a search keyword and optional genre/type filters. The Actor queries the public Discogs REST API, paginates through results, fetches thumbnail images from individual release pages, and emits one structured record per release.

#### 📏 How complete is the data?

All 12 fields are populated for every record. Image URLs come from individual release detail calls. Genre, style, and format are arrays - some releases have one value, others have several. The `error` field is only populated when a record fails to fetch.

#### 🔁 How often is the dataset refreshed?

Discogs data is updated by its community continuously. Every run of this Actor fetches the latest catalog, so your dataset reflects the current state of the database at run time.

#### 🎸 What genres are supported?

Any genre recognized by Discogs, including Rock, Jazz, Electronic, Hip Hop, Classical, Folk, World & Country, Pop, Funk / Soul, Blues, Latin, Stage & Screen, Reggae, Non-Music, Children's, and Brass & Military.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) to keep a downstream music catalog current.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan works for testing and small runs (10 records). A paid plan lifts the limit and gives access to scheduling and larger datasets.

#### ⏱️ How long does a 100-item run take?

Approximately 4-6 minutes. Each record requires one extra API call to fetch the thumbnail image, and the Discogs API enforces rate limits that require ~2.6 seconds between calls.

#### 🔒 Do I need a Discogs account?

No. The Actor uses only the public Discogs API endpoints which are available without authentication.

#### 🔁 What happens if the API rate-limits the run?

The Actor detects HTTP 429 responses and automatically waits 60 seconds before retrying. No data is lost and the run continues from where it paused.

#### 🏷️ Why does the title include the artist name?

Discogs formats release titles as "Artist - Album Title" in its search API. The Actor parses this to populate the separate `artist` field, but also preserves the original full title.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Discogs Music Releases Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step music catalog workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe music data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh release data into your music app backend, or alert your team in Slack when a new batch is ready.

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [**🏪 Bandcamp Scraper**](https://apify.com/parseforge/bandcamp-scraper) | Independent music releases, prices, and artist pages from Bandcamp |
| [**🎮 Itch.io Scraper**](https://apify.com/parseforge/itch-io-scraper) | Game and creative project listings from the indie marketplace |
| [**🎬 Letterboxd Scraper**](https://apify.com/parseforge/letterboxd-scraper) | Film ratings, reviews, and catalog data from Letterboxd |
| [**🎯 Metacritic Scraper**](https://apify.com/parseforge/metacritic-scraper) | Critic and user scores for games, films, and music albums |
| [**🌐 Dev.to Scraper**](https://apify.com/parseforge/dev-to-scraper) | Technical articles and developer content from Dev.to |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more structured public-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Discogs or Zink Media, LLC. All trademarks mentioned are the property of their respective owners. Only publicly available data accessible through the Discogs public REST API is collected.

# Actor input Schema

## `search` (type: `string`):

Keyword to search for on Discogs (e.g. 'nirvana', 'dark side of the moon', 'miles davis')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

The type of Discogs entry to search for

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

Optional genre to filter results (e.g. 'Rock', 'Jazz', 'Electronic', 'Hip Hop')

## Actor input object example

```json
{
  "search": "nirvana",
  "maxItems": 10,
  "type": "release"
}
```

# Actor output Schema

## `results` (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 = {
    "search": "nirvana",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "search": "nirvana",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "search": "nirvana",
  "maxItems": 10
}' |
apify call parseforge/discogs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discogs Scraper",
        "description": "Scrape music releases, artists, and labels from Discogs. Get album titles, artists, years, genres, styles, formats, countries, tracklists, and community have/want stats for millions of records. Filter by type, year, country, genre, style, and format.",
        "version": "0.1",
        "x-build-id": "Pb70c2XXt6cPodaEh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~discogs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~discogs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~discogs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "required": [
                    "search"
                ],
                "properties": {
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for on Discogs (e.g. 'nirvana', 'dark side of the moon', 'miles davis')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "type": {
                        "title": "Search Type",
                        "enum": [
                            "release",
                            "master",
                            "artist",
                            "label"
                        ],
                        "type": "string",
                        "description": "The type of Discogs entry to search for",
                        "default": "release"
                    },
                    "genre": {
                        "title": "Genre Filter",
                        "type": "string",
                        "description": "Optional genre to filter results (e.g. 'Rock', 'Jazz', 'Electronic', 'Hip Hop')"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
