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

Scrape Discogs, the world's largest music database and marketplace. Search releases, masters, artists, and labels; pull full discographies; resolve marketplace listings and price stats. HTTP-only via the official Discogs API.

- **URL**: https://apify.com/crawlerbros/discogs-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Discogs Scraper

Scrape **Discogs** — the world's largest music database and marketplace, covering 17M+ releases, 9M+ artists, and 2M+ labels across every genre and physical format. HTTP-only via the official `api.discogs.com` REST API. Anonymous reads work; an optional personal access token raises rate limits from 25 req/min to 60 req/min.

### What this actor does

- **12 modes** — search the database, lookup by release/master/artist/label/listing, fetch full discographies, marketplace stats, or any Discogs URL
- **Universal IDs** — numeric Discogs release IDs, master IDs, artist IDs, label IDs, listing IDs
- **Filters** — type, format, genre, style, country, year range, collection have/want, marketplace condition
- **Marketplace stats** — number for sale, lowest price, currency for any release
- **Empty fields are omitted**

### Modes

| Mode | What it returns | Required input |
|---|---|---|
| `search` | Free-text search of releases / masters / artists / labels | `searchQuery` |
| `byRelease` | Single release with full tracklist + community stats | `releaseId` |
| `byMaster` | Master release (canonical work, all pressings collapsed) | `masterId` |
| `byMasterVersions` | Every pressing/version of a master | `masterId` |
| `byArtist` | Artist profile, members, aliases, name variations | `artistId` |
| `byArtistReleases` | Full discography of an artist | `artistId` |
| `byLabel` | Label profile, sublabels, parent label | `labelId` |
| `byLabelReleases` | Full release catalog of a label | `labelId` |
| `byMarketplaceListing` | Single marketplace listing with seller, condition, price | `listingId` |
| `marketplaceSearch` | Search releases + enrich with marketplace stats | `searchQuery` |
| `marketplaceStats` | Number for sale / lowest price for a release | `releaseId` |
| `byUrl` | Resolve any Discogs URL (release / master / artist / label / listing) | `urls` |

### Output per record

Common fields:
- `id` — Discogs numeric ID
- `recordType` — `release` / `master` / `artist` / `label` / `marketplaceListing` / `marketplaceStats`
- `title` / `name` — primary string identifier
- `discogsUrl` — canonical URL on www.discogs.com
- `coverImage` / `image` — CDN URL when available
- `dataQuality` — Discogs editorial quality flag
- `scrapedAt` — ISO 8601 UTC timestamp

Release-specific:
- `year`, `released`, `country`
- `artists[]` (with `id`, `name`, `url`), `primaryArtist`
- `labels[]` (with `id`, `name`, `catno`, `url`), `catno`
- `formats[]`, `formatDescriptions[]`, `formatQuantity`
- `genres[]`, `styles[]`
- `notes`, `status`
- `tracklist[]` (with `position`, `title`, `duration`)
- `have`, `want`, `ratingAverage`, `ratingCount`
- `numForSale`, `lowestPrice`
- `masterId`, `masterUrl`

Master-specific:
- `mainReleaseId`, `mainReleaseUrl`, `mostRecentReleaseId`, `mostRecentReleaseUrl`

Artist-specific:
- `realName`, `profile`, `nameVariations[]`, `aliases[]`, `members[]`, `urls[]`

Label-specific:
- `profile`, `contactInfo`, `urls[]`, `sublabels[]`, `parentLabel`

Marketplace listing:
- `condition`, `sleeveCondition`, `comments`, `shipsFrom`
- `price`, `currency`, `shippingPrice`, `allowOffers`
- `seller` (with `username`, `rating`, `totalRatings`)
- `release` (id/title/year/format/url)

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `search` | Mode dispatcher |
| `searchQuery` | string | `miles davis` | Free-text query |
| `type` | enum | `release` | release / master / artist / label / any |
| `format` | enum | `any` | Vinyl, CD, Cassette, etc. |
| `genre` | enum | `any` | Discogs top-level genre |
| `style` | string | – | Specific style, e.g. `Free Jazz` |
| `country` | string | – | Country of release |
| `yearMin`, `yearMax` | int | – | Year range |
| `releaseId`, `masterId`, `artistId`, `labelId`, `listingId` | string | – | Numeric IDs |
| `urls` | array | – | Discogs URLs (mode=byUrl) |
| `sortBy` | enum | `default` | year / title / format / label / artist / catno / country / have / want |
| `sortOrder` | enum | `desc` | asc / desc |
| `minHave` | int | – | Drop releases owned by fewer collectors |
| `minWant` | int | – | Drop releases wanted by fewer collectors |
| `marketplaceCondition` | enum | `any` | Mint / NM / VG+ / VG / G+ / G / F / P |
| `apiToken` | string (secret) | – | Optional Discogs personal access token (60 req/min) |
| `userAgent` | string | (apify default) | Custom User-Agent |
| `maxItems` | int | `50` | 1–10000 |

#### Example: search for jazz vinyl

```json
{
  "mode": "search",
  "searchQuery": "miles davis",
  "type": "release",
  "format": "Vinyl",
  "genre": "Jazz",
  "yearMin": 1955,
  "yearMax": 1975
}
````

#### Example: full Nickelback discography

```json
{
  "mode": "byArtistReleases",
  "artistId": "108713",
  "sortBy": "year",
  "sortOrder": "asc",
  "maxItems": 200
}
```

#### Example: Discogs URL batch

```json
{
  "mode": "byUrl",
  "urls": [
    "https://www.discogs.com/release/7426074-Miles-Davis-Miles-Davis-At-Fillmore",
    "https://www.discogs.com/master/65664-Miles-Davis-Miles-Davis-At-Fillmore",
    "https://www.discogs.com/artist/108713-Nickelback"
  ]
}
```

### Use cases

- **Music intelligence** — pull entire catalogs for record labels and artists
- **Vinyl pricing** — track marketplace prices and rarity (have/want ratios)
- **Discography research** — every pressing of every album, with country-of-issue
- **Genre / style mining** — comprehensive Discogs taxonomy across 16 root genres
- **Artist relationships** — aliases, group memberships, name variations
- **Label catalogs** — every release on a label, including sublabels

### FAQ

**Do I need a Discogs API token?**  No. Anonymous reads work for every endpoint. A token only raises rate limits from 25 to 60 req/min.

**Why do I see `25 req/min` warnings?**  Discogs throttles anonymous traffic. The actor sleeps ~1.1 s between requests so it never crosses the limit.

**What's the difference between a release and a master?**  A *master* is the canonical recorded work (e.g. Miles Davis at Fillmore). A *release* is one specific pressing of it (US 1970 Columbia LP, Japan 1985 reissue, etc.). One master has many releases.

**Can I scrape user wantlists or collections?**  No — those endpoints require user auth (OAuth) and aren't supported by this actor.

**Why is `marketplaceSearch` slow?**  Each result is enriched with a separate `/marketplace/stats/{id}` call to get number-for-sale and lowest-price. We cap at the configured rate limit.

**Are images included?**  The first cover image URL is exposed as `coverImage`. Full image lists require auth.

### Limitations

- User-specific endpoints (collection, wantlist, identity) require OAuth and aren't supported.
- Marketplace condition is annotated, not strictly server-side filtered (Discogs marketplace search is OAuth-only at the listing level).
- Anonymous rate limit (25 req/min) makes runs over a few hundred items slow.

# Actor input Schema

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

What to fetch. Use `search` for free-text database queries, `byRelease`/`byMaster`/`byArtist`/`byLabel` to look up records by ID, or `marketplaceSearch`/`marketplaceStats` for marketplace pricing data.

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

Free-text query for `mode=search` or `mode=marketplaceSearch`. Example: `miles davis`, `kind of blue`, `daft punk`.

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

Restrict search to a particular Discogs entity (mode=search). `release` returns specific pressings; `master` returns canonical works.

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

Filter to a physical or digital format (mode=search).

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

Discogs genre filter (mode=search).

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

Discogs style filter, e.g. `House`, `Free Jazz`, `Hard Rock` (mode=search).

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

Country of release, free-text (e.g. `US`, `UK`, `Germany`) (mode=search).

## `yearMin` (type: `integer`):

Drop releases issued before this year.

## `yearMax` (type: `integer`):

Drop releases issued after this year.

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

Discogs numeric release ID, e.g. `7426074`.

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

Discogs numeric master ID, e.g. `65664`.

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

Discogs numeric artist ID, e.g. `108713`.

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

Discogs numeric label ID, e.g. `1`.

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

Discogs marketplace listing ID.

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

Direct Discogs URLs (release / master / artist / label / listing).

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

Sort order for search and discography modes.

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

Ascending or descending.

## `minHave` (type: `integer`):

Drop releases owned by fewer collectors than this.

## `minWant` (type: `integer`):

Drop releases wanted by fewer collectors than this.

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

Filter marketplace search by media condition.

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

Discogs personal access token. Increases rate limits from 25 req/min (anonymous) to 60 req/min (authenticated). Anonymous works fine for small runs. Get one at https://www.discogs.com/settings/developers.

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

Discogs requires a custom User-Agent string identifying your app.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "miles davis",
  "type": "release",
  "format": "any",
  "genre": "any",
  "urls": [],
  "sortBy": "default",
  "sortOrder": "desc",
  "marketplaceCondition": "any",
  "userAgent": "Apify-DiscogsScraper/1.0 +https://apify.com",
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Discogs records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "miles davis",
    "type": "release",
    "format": "any",
    "genre": "any",
    "urls": [],
    "sortBy": "default",
    "sortOrder": "desc",
    "marketplaceCondition": "any",
    "userAgent": "Apify-DiscogsScraper/1.0 +https://apify.com",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/discogs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchQuery": "miles davis",
    "type": "release",
    "format": "any",
    "genre": "any",
    "urls": [],
    "sortBy": "default",
    "sortOrder": "desc",
    "marketplaceCondition": "any",
    "userAgent": "Apify-DiscogsScraper/1.0 +https://apify.com",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "search",
  "searchQuery": "miles davis",
  "type": "release",
  "format": "any",
  "genre": "any",
  "urls": [],
  "sortBy": "default",
  "sortOrder": "desc",
  "marketplaceCondition": "any",
  "userAgent": "Apify-DiscogsScraper/1.0 +https://apify.com",
  "maxItems": 50
}' |
apify call crawlerbros/discogs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discogs Scraper",
        "description": "Scrape Discogs, the world's largest music database and marketplace. Search releases, masters, artists, and labels; pull full discographies; resolve marketplace listings and price stats. HTTP-only via the official Discogs API.",
        "version": "1.0",
        "x-build-id": "ZEKaSojPpLbZ19Lwg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~discogs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~discogs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~discogs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byRelease",
                            "byMaster",
                            "byMasterVersions",
                            "byArtist",
                            "byArtistReleases",
                            "byLabel",
                            "byLabelReleases",
                            "byMarketplaceListing",
                            "marketplaceSearch",
                            "marketplaceStats",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch. Use `search` for free-text database queries, `byRelease`/`byMaster`/`byArtist`/`byLabel` to look up records by ID, or `marketplaceSearch`/`marketplaceStats` for marketplace pricing data.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query for `mode=search` or `mode=marketplaceSearch`. Example: `miles davis`, `kind of blue`, `daft punk`.",
                        "default": "miles davis"
                    },
                    "type": {
                        "title": "Search type",
                        "enum": [
                            "any",
                            "release",
                            "master",
                            "artist",
                            "label"
                        ],
                        "type": "string",
                        "description": "Restrict search to a particular Discogs entity (mode=search). `release` returns specific pressings; `master` returns canonical works.",
                        "default": "release"
                    },
                    "format": {
                        "title": "Format",
                        "enum": [
                            "any",
                            "Vinyl",
                            "CD",
                            "Cassette",
                            "DVD",
                            "Blu-ray",
                            "File",
                            "Box Set",
                            "Reel-To-Reel",
                            "8-Track Cartridge",
                            "Flexi-disc",
                            "Acetate",
                            "Shellac",
                            "Mini-Disc",
                            "DAT",
                            "VHS",
                            "Memory Stick",
                            "SACD",
                            "HDCD",
                            "All Media"
                        ],
                        "type": "string",
                        "description": "Filter to a physical or digital format (mode=search).",
                        "default": "any"
                    },
                    "genre": {
                        "title": "Genre",
                        "enum": [
                            "any",
                            "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": "Discogs genre filter (mode=search).",
                        "default": "any"
                    },
                    "style": {
                        "title": "Style",
                        "type": "string",
                        "description": "Discogs style filter, e.g. `House`, `Free Jazz`, `Hard Rock` (mode=search)."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country of release, free-text (e.g. `US`, `UK`, `Germany`) (mode=search)."
                    },
                    "yearMin": {
                        "title": "Year (min)",
                        "minimum": 1890,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop releases issued before this year."
                    },
                    "yearMax": {
                        "title": "Year (max)",
                        "minimum": 1890,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop releases issued after this year."
                    },
                    "releaseId": {
                        "title": "Release ID (mode=byRelease)",
                        "type": "string",
                        "description": "Discogs numeric release ID, e.g. `7426074`."
                    },
                    "masterId": {
                        "title": "Master ID (mode=byMaster / byMasterVersions)",
                        "type": "string",
                        "description": "Discogs numeric master ID, e.g. `65664`."
                    },
                    "artistId": {
                        "title": "Artist ID (mode=byArtist / byArtistReleases)",
                        "type": "string",
                        "description": "Discogs numeric artist ID, e.g. `108713`."
                    },
                    "labelId": {
                        "title": "Label ID (mode=byLabel / byLabelReleases)",
                        "type": "string",
                        "description": "Discogs numeric label ID, e.g. `1`."
                    },
                    "listingId": {
                        "title": "Listing ID (mode=byMarketplaceListing)",
                        "type": "string",
                        "description": "Discogs marketplace listing ID."
                    },
                    "urls": {
                        "title": "Discogs URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct Discogs URLs (release / master / artist / label / listing).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "default",
                            "year",
                            "title",
                            "format",
                            "label",
                            "artist",
                            "catno",
                            "country",
                            "have",
                            "want"
                        ],
                        "type": "string",
                        "description": "Sort order for search and discography modes.",
                        "default": "default"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending.",
                        "default": "desc"
                    },
                    "minHave": {
                        "title": "Min collection 'have' count",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop releases owned by fewer collectors than this."
                    },
                    "minWant": {
                        "title": "Min wantlist count",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop releases wanted by fewer collectors than this."
                    },
                    "marketplaceCondition": {
                        "title": "Marketplace condition (record)",
                        "enum": [
                            "any",
                            "Mint (M)",
                            "Near Mint (NM or M-)",
                            "Very Good Plus (VG+)",
                            "Very Good (VG)",
                            "Good Plus (G+)",
                            "Good (G)",
                            "Fair (F)",
                            "Poor (P)"
                        ],
                        "type": "string",
                        "description": "Filter marketplace search by media condition.",
                        "default": "any"
                    },
                    "apiToken": {
                        "title": "Discogs personal access token (optional)",
                        "type": "string",
                        "description": "Discogs personal access token. Increases rate limits from 25 req/min (anonymous) to 60 req/min (authenticated). Anonymous works fine for small runs. Get one at https://www.discogs.com/settings/developers."
                    },
                    "userAgent": {
                        "title": "User-Agent contact",
                        "type": "string",
                        "description": "Discogs requires a custom User-Agent string identifying your app.",
                        "default": "Apify-DiscogsScraper/1.0 +https://apify.com"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
