# Discogs Marketplace Price & Demand Scraper (`automation-lab/discogs-marketplace-price-demand-scraper`) Actor

💿 Snapshot Discogs release prices, supply, collector demand, ratings, formats, labels, and catalog metadata from search or release, artist, and label IDs.

- **URL**: https://apify.com/automation-lab/discogs-marketplace-price-demand-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Discogs 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](https://apify.com/automation-lab/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

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

#### Direct release example

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

#### Label monitoring example

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

### Output example

```json
{
  "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

```javascript
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

```python
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

```bash
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:

```bash
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:

```bash
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:

```json
{
  "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](https://apify.com/automation-lab/ebay-sold-listings-scraper) — analyze completed eBay listing signals for resale research.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) — extract active eBay listings and product details.
- [Bandcamp Scraper](https://apify.com/automation-lab/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](https://apify.com/automation-lab/discogs-marketplace-price-demand-scraper)

# Actor input Schema

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

Search by artist, album, catalog number, barcode, or other free text.

## `releaseIds` (type: `array`):

Discogs release IDs or release URLs to snapshot directly.

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

Discover releases from one or more Discogs artist IDs or artist URLs.

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

Discover releases from one or more Discogs label IDs or label URLs.

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

Stop after saving this many unique release snapshots.

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

Optional Discogs search year, such as 1997. Applies to query discovery.

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

Optional release country, such as US, UK, or Germany.

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

Optional Discogs genre, such as Rock or Electronic.

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

Optional Discogs style, such as Alternative Rock or House.

## `includeMarketplaceStats` (type: `boolean`):

Fetch the dedicated marketplace stats endpoint for current number for sale, lowest price, currency, and sale-block status.

## Actor input object example

```json
{
  "query": "Radiohead OK Computer",
  "releaseIds": [],
  "artistIds": [],
  "labelIds": [],
  "maxItems": 5,
  "includeMarketplaceStats": true
}
```

# Actor output Schema

## `overview` (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 = {
    "query": "Radiohead OK Computer",
    "releaseIds": [],
    "artistIds": [],
    "labelIds": [],
    "maxItems": 5,
    "includeMarketplaceStats": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/discogs-marketplace-price-demand-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 = {
    "query": "Radiohead OK Computer",
    "releaseIds": [],
    "artistIds": [],
    "labelIds": [],
    "maxItems": 5,
    "includeMarketplaceStats": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/discogs-marketplace-price-demand-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 '{
  "query": "Radiohead OK Computer",
  "releaseIds": [],
  "artistIds": [],
  "labelIds": [],
  "maxItems": 5,
  "includeMarketplaceStats": true
}' |
apify call automation-lab/discogs-marketplace-price-demand-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discogs Marketplace Price & Demand Scraper",
        "description": "💿 Snapshot Discogs release prices, supply, collector demand, ratings, formats, labels, and catalog metadata from search or release, artist, and label IDs.",
        "version": "0.1",
        "x-build-id": "o2BlF1KqjCSk9flrG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~discogs-marketplace-price-demand-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-discogs-marketplace-price-demand-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/automation-lab~discogs-marketplace-price-demand-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-discogs-marketplace-price-demand-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/automation-lab~discogs-marketplace-price-demand-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-discogs-marketplace-price-demand-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "🔎 Release search query",
                        "type": "string",
                        "description": "Search by artist, album, catalog number, barcode, or other free text."
                    },
                    "releaseIds": {
                        "title": "💿 Release IDs or URLs",
                        "type": "array",
                        "description": "Discogs release IDs or release URLs to snapshot directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "artistIds": {
                        "title": "🎤 Artist IDs or URLs",
                        "type": "array",
                        "description": "Discover releases from one or more Discogs artist IDs or artist URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "labelIds": {
                        "title": "🏷️ Label IDs or URLs",
                        "type": "array",
                        "description": "Discover releases from one or more Discogs label IDs or label URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum releases",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after saving this many unique release snapshots.",
                        "default": 5
                    },
                    "year": {
                        "title": "📅 Year filter",
                        "type": "string",
                        "description": "Optional Discogs search year, such as 1997. Applies to query discovery."
                    },
                    "country": {
                        "title": "Country filter",
                        "type": "string",
                        "description": "Optional release country, such as US, UK, or Germany."
                    },
                    "genre": {
                        "title": "Genre filter",
                        "type": "string",
                        "description": "Optional Discogs genre, such as Rock or Electronic."
                    },
                    "style": {
                        "title": "Style filter",
                        "type": "string",
                        "description": "Optional Discogs style, such as Alternative Rock or House."
                    },
                    "includeMarketplaceStats": {
                        "title": "💵 Refresh marketplace stats",
                        "type": "boolean",
                        "description": "Fetch the dedicated marketplace stats endpoint for current number for sale, lowest price, currency, and sale-block status.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```