# Reverb Musical Instruments Marketplace Scraper (`automation-lab/reverb-musical-instruments-marketplace-scraper`) Actor

Search and export active Reverb musical gear listings with prices, condition, seller, inventory, shipping, timestamps, and photos.

- **URL**: https://apify.com/automation-lab/reverb-musical-instruments-marketplace-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Reverb Musical Instruments Marketplace Scraper

Search active Reverb musical-gear inventory and export clean listing records.

This Apify Actor turns keywords or public Reverb marketplace search URLs into analysis-ready rows with prices, condition, make, model, seller shop, inventory, shipping, timestamps, descriptions, and photos.

It is built for recurring price monitoring, sourcing, valuation, and inventory research without browser automation.

### What does this Reverb scraper do?

The Actor queries Reverb's anonymous marketplace listings surface.

It can:

- search one or many instrument keywords;
- reuse a public `reverb.com/marketplace` search URL;
- filter used or new inventory;
- apply minimum and maximum buyer prices;
- sort by relevance, publication time, or price;
- target a shipping destination;
- follow pagination up to an exact result limit;
- deduplicate overlapping searches by stable listing ID;
- export JSON, CSV, Excel, XML, or RSS through Apify datasets.

The default dataset contains one row per active listing.

Sold-listing history and Reverb price-guide estimates are outside this Actor's scope.

### Who is it for?

#### Music retailers

Take scheduled snapshots of competing shops, models, conditions, and asking prices.

#### Gear resellers and sourcing teams

Find fresh used inventory inside a target price range and route it to a spreadsheet or alerting workflow.

#### Valuators and appraisers

Collect current asking-price comparables with make, model, year, finish, and condition context.

#### Market researchers

Build repeatable category or keyword samples without manually copying marketplace cards.

#### Developers and data teams

Feed normalized Reverb records into a warehouse, dashboard, matching model, or internal API.

### Why use this Actor?

- **HTTP-only extraction:** no browser startup or image downloads are required.
- **Two input routes:** use buyer keywords or preserve a Reverb marketplace search URL.
- **Exact limits:** `maxItems` applies across every source in a run.
- **Stable deduplication:** overlapping searches do not emit the same listing twice.
- **Typed output:** money, booleans, arrays, timestamps, and nested shipping fields remain structured.
- **Useful descriptions:** both plain text and source HTML are included.
- **Bounded recovery:** transient timeouts, rate limits, and temporary server failures use conservative backoff.

### What data can I extract?

| Field | Meaning |
| --- | --- |
| `listingId` | Stable numeric Reverb listing ID |
| `url` | Canonical public item URL |
| `apiUrl` | Public JSON detail endpoint |
| `title` | Seller's listing title |
| `make`, `model` | Reverb make and model fields |
| `year`, `finish` | Seller-provided year and finish |
| `condition`, `conditionSlug` | Display and normalized condition |
| `price`, `currency` | Structured displayed buyer price |
| `displayPrice` | Reverb-formatted price string |
| `listingCurrency` | Seller's original currency when available |
| `buyerPrice`, `buyerCurrency` | Buyer-facing converted price |
| `sellerShop` | Reverb shop name |
| `description` | Plain-text description |
| `descriptionHtml` | Original description HTML |
| `inventory`, `hasInventory` | Stock information |
| `sku`, `state` | Seller SKU and listing state |
| `offersEnabled`, `auction` | Sale-format flags |
| `categories` | Reverb category UUIDs |
| `shipping` | Local pickup, US shipping, and US rate |
| `photos` | Full or large photo URLs |
| `createdAt`, `publishedAt` | Source timestamps |
| `searchQuery`, `sourceUrl` | Search provenance |
| `scrapedAt` | Extraction timestamp |

Fields can be `null` when a seller or Reverb does not provide them.

### How to scrape Reverb listings

1. Open the Actor input page.
2. Add one or more search terms, or paste a Reverb marketplace URL.
3. Choose condition, price, sorting, and destination filters if needed.
4. Set `maxItems` for the total unique listings required.
5. Start the run.
6. Open the **Reverb listings** dataset view.
7. Export the rows or connect the dataset to your downstream system.

Start with 25 results while confirming that the query matches your workflow.

Increase the limit for scheduled inventory snapshots after checking output quality.

### Input parameters

#### `searchTerms`

An array of non-empty Reverb searches.

Examples:

- `Fender Jazzmaster`
- `Gibson Les Paul`
- `Moog synthesizer`
- `vintage tube amplifier`

At least one `searchTerms` value or `startUrls` entry is required.

#### `startUrls`

Public URLs with this shape:

`https://reverb.com/marketplace?query=Moog%20synthesizer&condition=used`

The Actor forwards supported query, condition, price, sorting, destination, and category parameters.

Individual `/item/` detail URLs are not accepted.

#### Shared filters

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `condition` | string | `all` | `all`, `used`, or `new` |
| `minPrice` | number | none | Non-negative buyer price |
| `maxPrice` | number | none | Must be at least `minPrice` |
| `sort` | string | `relevance` | `relevance`, `published_at`, or `price` |
| `order` | string | `desc` | `desc` or `asc` |
| `shipsTo` | string | none | Uppercase country code such as `US` |
| `maxItems` | integer | `25` | 1 to 10,000 unique listings |

Shared filters override matching values in each marketplace URL so every source follows the same run scope.

### Example input: used Fender Jazzmasters

```json
{
  "searchTerms": ["Fender Jazzmaster"],
  "condition": "used",
  "sort": "published_at",
  "order": "desc",
  "maxItems": 25
}
```

### Example input: recurring retailer snapshot

```json
{
  "searchTerms": ["Gibson Les Paul"],
  "condition": "used",
  "minPrice": 500,
  "maxPrice": 2500,
  "sort": "published_at",
  "order": "desc",
  "shipsTo": "US",
  "maxItems": 200
}
```

### Example output

The values below illustrate the current output shape; live listings change continuously.

```json
{
  "listingId": 12345678,
  "url": "https://reverb.com/item/12345678-example-electric-guitar",
  "apiUrl": "https://reverb.com/api/listings/12345678-example-electric-guitar",
  "title": "Example electric guitar in sunburst",
  "make": "Example Brand",
  "model": "Model 60",
  "year": "2020",
  "finish": "Sunburst",
  "condition": "Excellent",
  "conditionSlug": "excellent",
  "price": 1299.99,
  "currency": "USD",
  "displayPrice": "$1,299.99",
  "listingCurrency": "USD",
  "buyerPrice": 1299.99,
  "buyerCurrency": "USD",
  "sellerShop": "Example Music Shop",
  "description": "Well-maintained instrument with a padded case.",
  "inventory": 1,
  "hasInventory": true,
  "sku": "SKU-EXAMPLE-01",
  "state": "live",
  "offersEnabled": true,
  "auction": false,
  "categories": ["00000000-0000-4000-8000-000000000001"],
  "shipping": { "local": true, "us": true, "usRate": 35 },
  "photos": ["https://rvb-img.reverb.com/i/example.jpg"],
  "createdAt": "2025-01-15T12:00:00-05:00",
  "publishedAt": "2025-01-16T09:30:00-05:00",
  "searchQuery": "example electric guitar",
  "sourceUrl": "https://reverb.com/marketplace?query=example%20electric%20guitar",
  "scrapedAt": "2025-01-20T14:30:00.000Z"
}
```

### How much does it cost to scrape Reverb musical instrument listings?

Pay-per-event pricing has two parts:

- **$0.005 per run** for the `start` event;
- a tiered `item` event for each saved listing.

| Apify tier | Price per listing |
| --- | ---: |
| Free | $0.000041071 |
| Bronze | $0.000035714 |
| Silver | $0.000027857 |
| Gold | $0.000021429 |
| Platinum | $0.000014286 |
| Diamond | $0.000010000 |

Free-tier examples:

- 25 listings: **about $0.00603**
- 100 listings: **about $0.00911**
- 1,000 listings: **about $0.04607**

No listing event is charged for duplicates, rejected rows, or empty result pages.

Platform usage and final charge details remain visible on each Apify run.

### Scheduling price and inventory monitoring

Use Apify Schedules to run the same input hourly, daily, or weekly.

A practical retailer workflow is:

1. search one model family;
2. filter to the condition and price band you stock;
3. sort newest first;
4. save 100–500 rows;
5. export the dataset to Google Sheets or a webhook;
6. compare stable `listingId` values with the prior snapshot.

The Actor returns snapshots, not a built-in historical database.

Your downstream workflow should store prior runs when change history matters.

### Integrations

Dataset results work with:

- Google Sheets;
- Slack and email automation;
- Make;
- Zapier;
- webhooks;
- Python and JavaScript clients;
- BI tools and warehouses;
- Apify Schedules and Actor-to-Actor pipelines.

Use `listingId` as the preferred join and deduplication key.

Use `publishedAt` and `scrapedAt` separately: one is source freshness, the other is collection time.

### Run with the Apify API using cURL

Replace `YOUR_TOKEN` with an Apify API token.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~reverb-musical-instruments-marketplace-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["Fender Jazzmaster"],
    "condition": "used",
    "maxItems": 25
  }'
```

For production, pass tokens through environment variables instead of source code.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor(
  'automation-lab/reverb-musical-instruments-marketplace-scraper'
).call({
  searchTerms: ['Gibson Les Paul'],
  condition: 'used',
  minPrice: 500,
  maxPrice: 2500,
  maxItems: 100,
});

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

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor(
    "automation-lab/reverb-musical-instruments-marketplace-scraper"
).call(run_input={
    "searchTerms": ["Moog synthesizer"],
    "condition": "used",
    "maxItems": 50,
})

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

### Use with MCP and AI agents

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/reverb-musical-instruments-marketplace-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use the same remote MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/reverb-musical-instruments-marketplace-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 recently published used Fender Jazzmasters on Reverb."
- "Export Moog synthesizer listings and group them by condition and price."
- "Collect Gibson Les Paul inventory between $500 and $2,500 that ships to the US."

### Performance and limits

The Actor requests up to 50 marketplace rows per page.

A small direct-HTTP run normally completes quickly and fits the 256 MB memory configuration.

Large limits require more pagination and increase runtime linearly.

Reverb can change its anonymous API, filters, field availability, or anti-automation controls.

Transient 429 and 5xx responses are retried with bounded exponential backoff.

Stable authorization errors, malformed inputs, and unexpected response shapes fail the run instead of returning a misleading empty dataset.

### Data quality notes

- Prices are asking prices, not completed-sale prices.
- Currency conversion is controlled by Reverb and can differ from the seller's listing currency.
- Seller descriptions may contain formatting or imperfect text encoding.
- Category values are UUIDs because that is what the listings response exposes.
- Shipping fields do not guarantee delivery eligibility at checkout.
- Inventory can be absent or stale when sellers do not maintain it.
- Listings can change or disappear after collection.

### Responsible use and legality

This Actor collects publicly accessible marketplace listing data.

You are responsible for how you use, retain, and share the results.

Review Reverb's current terms, applicable database rights, privacy rules, and local law for your use case.

Do not use the Actor to harass sellers, bypass access controls, republish protected images or descriptions without permission, or make deceptive valuation claims.

Keep collection frequency and volume proportionate to a legitimate business or research need.

### Troubleshooting

#### The Actor says an input source is required

Add at least one non-empty `searchTerms` value or one valid `https://reverb.com/marketplace?...` entry in `startUrls`.

#### A URL is rejected

Only Reverb marketplace search URLs are supported.

Paste `/marketplace` URLs, not product `/item/` pages or unrelated domains.

#### The dataset is empty

Open the same query on Reverb and check whether active inventory exists.

Try removing a narrow condition, destination, or price filter.

A successful empty run is expected for a query with no live matches.

#### A run fails with an upstream HTTP error

Check the run log for the status and retry count.

Retry later if Reverb is temporarily unavailable.

Do not repeatedly launch identical runs during an extended source outage.

#### I received fewer rows than `maxItems`

The source may have fewer unique matching listings.

Overlapping searches are deduplicated, so their combined raw total can exceed the saved total.

### Related Automation Lab actors

- [MusicBrainz Scraper](https://apify.com/automation-lab/musicbrainz-scraper) can enrich artist and release research with structured music metadata.
- [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) supports adjacent artist and catalog intelligence workflows.

These Actors do not replace Reverb marketplace inventory extraction; use them only when the wider music-data workflow needs those sources.

### FAQ

#### Does it scrape sold Reverb listings?

No. It exports active marketplace inventory and asking prices.

#### Does it require a Reverb login or API key?

No. The current implementation uses an anonymous listings JSON surface.

#### Does it use residential proxies?

No automatic proxy or browser mode is enabled.

#### Can I search multiple models in one run?

Yes. Add multiple `searchTerms` values; the global `maxItems` cap and deduplication apply across all of them.

#### Can I paste category URLs?

Paste public `/marketplace` search URLs with their supported category query parameters.

Other Reverb page paths are rejected rather than silently broadening the search.

#### Can I download the photos?

The dataset includes source photo URLs but the Actor does not download image binaries.

#### Can I use the results for appraisal?

The records can support comparable-listing research, but asking prices are not completed sales and are not a professional valuation on their own.

#### How do I keep historical snapshots?

Schedule runs and persist each default dataset in your warehouse, spreadsheet, or storage system.

Join snapshots on `listingId` to identify additions, removals, and price changes.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Reverb, such as an instrument, make, model, or finish. At least one search term or start URL is required.

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

Public https://reverb.com/marketplace search URLs. Supported query, condition, price, sorting, destination, and category parameters are transferred to the listings API.

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

Limit results to used or new gear. All preserves an unfiltered marketplace search.

## `minPrice` (type: `number`):

Minimum buyer price accepted by Reverb's marketplace API.

## `maxPrice` (type: `number`):

Maximum buyer price accepted by Reverb's marketplace API.

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

Ordering field passed to Reverb.

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

Ascending or descending order for the selected sort field.

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

Optional ISO 3166-1 alpha-2 destination, for example US, GB, or DE.

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

Maximum unique active listings saved across all searches and URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "Fender Jazzmaster"
  ],
  "condition": "all",
  "sort": "relevance",
  "order": "desc",
  "maxItems": 20
}
```

# Actor output Schema

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

All active Reverb listings returned by the run.

# 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 = {
    "searchTerms": [
        "Fender Jazzmaster"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/reverb-musical-instruments-marketplace-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 = {
    "searchTerms": ["Fender Jazzmaster"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reverb-musical-instruments-marketplace-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 '{
  "searchTerms": [
    "Fender Jazzmaster"
  ],
  "maxItems": 20
}' |
apify call automation-lab/reverb-musical-instruments-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/aZaL1BeHBmUNVk6dA/builds/9TFGIqLuNxEruIohi/openapi.json