Discogs Marketplace Price & Demand Scraper

Turn public Discogs release data into clean, repeatable marketplace snapshots.

Search by album, artist, catalog number, or barcode, or start from known release, artist, and label IDs. The Actor exports current supply, lowest asking price, collector demand, ratings, and detailed release metadata to a structured dataset.

• 💵 Track the current lowest marketplace price and currency.
• 📦 Compare numForSale with collector wantCount and haveCount.
• 💿 Enrich a catalog with formats, labels, catalog numbers, genres, and images.
• 🔁 Schedule identical inputs to build your own time series.
• ⚡ Use Discogs' structured API rather than fragile marketplace HTML.

Run Discogs Marketplace Price & Demand Scraper

What does Discogs Marketplace Price & Demand Scraper do?

The Actor discovers Discogs releases from four routes:

1. A free-text Discogs database search.
2. Direct release IDs or release URLs.
3. Releases associated with artist IDs or URLs.
4. Releases associated with label IDs or URLs.

For every unique release, it fetches the release record and, by default, the dedicated marketplace statistics record. It then saves one normalized row per release.

The output combines catalog identity and current market signals. That makes it useful for monitoring instead of only one-off browsing.

V1 does not scrape seller listing rows, seller identities, shipping quotes, or sold-price history. It reports the public current marketplace summary exposed for each release.

Who is it for?

Record dealers

• Compare supply and demand before sourcing inventory.
• Prioritize records with high wants relative to current supply.
• Refresh a stock list without copying values by hand.

Collectors and collection managers

• Snapshot watch-list releases.
• Identify releases with changing availability.
• Keep release metadata and cover images beside price signals.

Labels and rights holders

• Monitor releases associated with a label catalog.
• Export catalog numbers and format variants.
• Observe collector demand across reissues and territories.

Valuation and catalog applications

• Resolve Discogs release IDs into typed data.
• Feed current supply and asking-price signals into a model.
• Schedule repeat runs and calculate changes in your own database.

Marketplace analysts

• Compare wantCount, haveCount, numForSale, and ratings.
• Segment releases by country, year, genre, style, label, or format.
• Export to CSV, JSON, Excel, Google Sheets, or a database.

Why use this Discogs scraper?

Manual Discogs research is fine for one record. It becomes slow and inconsistent for a catalog.

This Actor provides:

• ✅ Four discovery routes in one input.
• ✅ Global release-ID deduplication across routes.
• ✅ Typed numbers for prices, supply, demand, and ratings.
• ✅ Stable Discogs release and API URLs.
• ✅ Bounded retries for temporary API errors.
• ✅ Adaptive pauses near the Discogs anonymous rate limit.
• ✅ No login, API token, browser, or proxy requirement for V1.
• ✅ Pay-per-result output suitable for small lookups and repeat monitoring.

What Discogs data can I extract?

Field	Type	Description
releaseId	number	Unique Discogs release ID
releaseUrl	string	Public Discogs release URL
apiUrl	string	Discogs API resource URL
title	string	Release title
artists	array	Normalized artist names
artistsText	string	Export-friendly artist text
year	number	Release year when available
releasedDate	string	Source release date
country	string	Release country
genres	array	Discogs genres
styles	array	Discogs styles
labels	array	Label names
catalogNumbers	array	Label catalog numbers
formats	array	Formats and format descriptions
haveCount	number	Discogs users who have the release
wantCount	number	Discogs users who want the release
ratingCount	number	Number of community ratings
ratingAverage	number	Average community rating
numForSale	number	Current marketplace copies for sale
lowestPrice	number	Current lowest listed price
lowestPriceCurrency	string	Currency returned by Discogs
blockedFromSale	boolean	Marketplace sale-block flag
masterId	number	Related master release ID
thumbnailUrl	string	Discogs thumbnail URL
coverImageUrl	string	Primary cover image URL
dateAdded	string	Discogs record creation timestamp
dateChanged	string	Discogs record update timestamp
scrapedAt	string	Actor snapshot timestamp

Missing optional source values are omitted rather than replaced with misleading placeholders.

How much does it cost to scrape Discogs prices?

This Actor uses pay-per-event pricing:

• A small one-time run start fee covers discovery and setup.
• Each saved release snapshot is charged as one result.
• Higher Apify plans receive tiered per-result discounts.

The final price appears in the Apify Console before you start a run. You can set a maximum total charge to control spend.

A five-release prefilled run is intentionally small. It is suitable for testing the data contract before increasing maxItems.

Discogs anonymous API limits also make conservative batches preferable. For monitoring, schedule focused catalogs instead of requesting unrelated bulk data.

How to scrape Discogs marketplace data

1. Open the Actor input page.
2. Enter a query, release IDs, artist IDs, label IDs, or a combination.
3. Set maxItems to the number of unique releases you need.
4. Add optional query filters such as year, country, genre, or style.
5. Keep Refresh marketplace stats enabled for current supply and lowest price.
6. Click Start.
7. Preview records in the Dataset tab.
8. Export the dataset or connect it to your workflow.

Input routes are deduplicated. If search and a direct ID both find the same release, the Actor saves it once.

Input parameters

Parameter	Type	Default	Purpose
query	string	Radiohead OK Computer	Free-text release search
releaseIds	array	[]	Release IDs or URLs
artistIds	array	[]	Artist IDs or URLs
labelIds	array	[]	Label IDs or URLs
maxItems	integer	5	Global unique release limit, 1–500
year	string	—	Search year filter
country	string	—	Search country filter
genre	string	—	Search genre filter
style	string	—	Search style filter
includeMarketplaceStats	boolean	true	Refresh dedicated marketplace stats

At least one discovery route is required. Invalid IDs and URLs fail closed with a clear error instead of silently searching something else.

Search example

{
  "query": "Radiohead OK Computer",
  "country": "UK",
  "maxItems": 10,
  "includeMarketplaceStats": true
}

Direct release example

{
  "releaseIds": [
    "249504",
    "https://www.discogs.com/release/1362375"
  ],
  "maxItems": 2,
  "includeMarketplaceStats": true
}

Label monitoring example

{
  "labelIds": ["https://www.discogs.com/label/895"],
  "maxItems": 50,
  "includeMarketplaceStats": true
}

Output example

{
  "releaseId": 249504,
  "releaseUrl": "https://www.discogs.com/release/249504",
  "apiUrl": "https://api.discogs.com/releases/249504",
  "title": "Never Gonna Give You Up",
  "artists": ["Rick Astley"],
  "artistsText": "Rick Astley",
  "year": 1987,
  "country": "UK",
  "genres": ["Electronic", "Pop"],
  "styles": ["Synth-pop"],
  "labels": ["RCA"],
  "catalogNumbers": ["PB 41447"],
  "formats": ["Vinyl — 7\" — 45 RPM — Single"],
  "haveCount": 4071,
  "wantCount": 580,
  "ratingCount": 350,
  "ratingAverage": 4.1,
  "numForSale": 121,
  "lowestPrice": 0.47,
  "lowestPriceCurrency": "USD",
  "masterId": 96559,
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}

Counts and prices are examples from a point in time. Marketplace values can change between runs.

Search, artist, label, and release workflows

Search workflow

Use query when you know a title, artist, barcode, or catalog number but not the release ID. Optional filters apply only to this route.

Release workflow

Use releaseIds for deterministic monitoring. Direct IDs avoid search ambiguity and are the best route for scheduled snapshots.

Artist workflow

Use artistIds to discover releases associated with an artist. Discogs may return master records; the Actor resolves those to their main release IDs.

Label workflow

Use labelIds for catalog monitoring. Large labels can contain many releases, so start with a modest maxItems.

Tips for accurate marketplace monitoring

• 🎯 Prefer direct release IDs after initial discovery.
• 🕒 Run on a consistent schedule when calculating changes.
• 💱 Store the currency with every price; do not compare numbers across currencies blindly.
• 📉 Treat lowest asking price as a current listing signal, not a completed-sale valuation.
• 📦 Compare supply with wants instead of using price alone.
• 🧾 Preserve releaseId as the primary key in downstream storage.
• 🔍 Use country and year filters to reduce ambiguous search results.
• 🚦 Keep batches conservative because anonymous Discogs API quotas apply.

Rate limits and reliability

The Actor uses Discogs' anonymous public API with a descriptive User-Agent.

Requests run conservatively and sequentially. Temporary 429 and server responses are retried a bounded number of times with backoff. The Actor pauses when the remaining quota is low.

A failed individual release is logged and skipped. If every discovered release fails, the run fails rather than reporting a false success with an empty dataset.

For the freshest marketplace values, keep includeMarketplaceStats enabled. Disable it only when release-level summary fields are enough and you want fewer API requests.

Export and integrations

Every run writes to the default Apify dataset. Export formats include JSON, CSV, Excel, XML, RSS, and JSONL.

Useful integration patterns include:

• Google Sheets: append scheduled snapshots, then chart lowest price and supply.
• Airtable: maintain a dealer sourcing table keyed by releaseId.
• Make: trigger a notification when supply falls below a threshold.
• Zapier: send newly monitored releases into a catalog workflow.
• Webhooks: process the dataset when a scheduled run finishes.
• Python/pandas: calculate want-to-supply ratios and price changes.
• Data warehouse: partition snapshots by scrapedAt for historical analysis.

Apify integrations can start runs, retrieve datasets, and notify external services without maintaining a scraper server.

JavaScript API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor(
  'automation-lab/discogs-marketplace-price-demand-scraper'
).call({
  releaseIds: ['249504', '1362375'],
  maxItems: 2,
  includeMarketplaceStats: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor(
    'automation-lab/discogs-marketplace-price-demand-scraper'
).call(run_input={
    'query': 'Radiohead OK Computer',
    'maxItems': 10,
    'includeMarketplaceStats': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL API example

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~discogs-marketplace-price-demand-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "artistIds": ["72872"],
    "maxItems": 10,
    "includeMarketplaceStats": true
  }'

Retrieve dataset items after the run finishes:

$curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"

Use with Apify MCP and AI agents

Connect the Actor to Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/discogs-marketplace-price-demand-scraper"

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/discogs-marketplace-price-demand-scraper"
    }
  }
}

Example prompts:

• “Snapshot the current supply, lowest price, and want count for these Discogs release IDs.”
• “Find ten UK releases matching this album and compare collector wants with copies for sale.”
• “Export a label catalog with formats, catalog numbers, price, and demand signals.”

The MCP server exposes the Actor as a callable tool while Apify handles execution and dataset storage.

Scheduling a Discogs price monitor

A single snapshot shows current conditions. Scheduled snapshots reveal movement.

1. Use direct release IDs for stable identity.
2. Save releaseId, lowestPrice, lowestPriceCurrency, numForSale, wantCount, and scrapedAt.
3. Create an Apify schedule at the frequency appropriate for your catalog.
4. Append each run's dataset to your own table or sheet.
5. Calculate changes between consecutive snapshots.
6. Alert only when a threshold is crossed.

This Actor does not manufacture historical data. Your scheduled runs create a transparent history from public snapshots.

Limitations

• Discogs anonymous API rate limits constrain throughput.
• The maximum run size is 500 unique releases.
• Search ordering is controlled by Discogs.
• Some releases lack dates, images, ratings, or prices.
• Lowest price is an asking-price signal, not a sold-price record.
• V1 excludes individual seller listings and shipping costs.
• V1 excludes condition-specific price suggestions and completed-sale history.
• Marketplace availability can change immediately after a snapshot.
• Discogs may alter public API fields or quota policies.

Is it legal to scrape Discogs data?

The Actor accesses public structured endpoints and does not bypass a login or scrape personal seller data in V1.

You are responsible for your use of the output. Review Discogs' terms, API policies, applicable database rights, copyright rules, and privacy laws. Respect rate limits and avoid republishing protected images or catalog content without appropriate rights.

Do not use the Actor to impersonate users, evade access controls, or make misleading valuation claims. Lowest listed price is not proof of fair value or a completed transaction.

Troubleshooting

Why did my run say no releases matched?

Check that at least one discovery input is present. Remove overly narrow search filters, verify spelling, or use a known release ID.

Why was an ID or URL rejected?

Use a positive numeric Discogs ID or a standard Discogs release, artist, or label URL. A master URL is not a direct release input; use its main release ID.

Why is lowestPrice missing?

A release may have no active marketplace listing, may be blocked from sale, or may not expose a lowest price at that moment. Check numForSale and blockedFromSale.

Why did the run slow down?

The Actor deliberately pauses near Discogs' anonymous rate limit. Reduce maxItems, disable marketplace refresh when appropriate, or divide a large catalog across scheduled periods.

Why are fewer rows saved than discovered?

Duplicate release IDs are saved once. Individual unavailable release records are skipped after bounded retries and listed in the run log.

FAQ

Do I need a Discogs API token?

No. V1 uses anonymously accessible public API endpoints.

Does this scrape sold prices?

No. It exports current marketplace supply and lowest asking price, not sold-price history.

Does it scrape every seller listing?

No. Seller listing rows, seller data, conditions, and shipping quotes are outside V1.

Can I monitor artist or label releases?

Yes. Supply artist or label IDs or URLs and schedule the same input repeatedly.

Can I combine input routes?

Yes. The Actor deduplicates release IDs found through search, direct releases, artists, and labels.

Can I export to CSV or Excel?

Yes. Use the Dataset export menu or dataset API.

Are numbers returned as numbers?

Yes. IDs, counters, ratings, and prices use numeric output types.

Will currency always be USD?

Do not assume that. Always read lowestPriceCurrency alongside lowestPrice.

Related scrapers

• eBay Sold Listings Scraper — analyze completed eBay listing signals for resale research.
• eBay Scraper — extract active eBay listings and product details.
• Bandcamp Scraper — collect public Bandcamp artist and album data.

Choose this Actor when Discogs release identity, supply, lowest asking price, and collector demand are the core workflow.

Start your first Discogs snapshot

Use the five-result prefill to inspect the schema in under two minutes. Then switch to direct release, artist, or label IDs for a repeatable monitoring workflow.

Open Discogs Marketplace Price & Demand Scraper