# Reverb Music Gear Marketplace Scraper (`crawlerbros/reverb-scraper`) Actor

Scrape Reverb.com the world's largest music gear marketplace. Search listings by keyword, condition, and price, or bulk-enrich specific listing URLs. Extracts title, price, condition, brand, photos, seller info, shipping, and more.

- **URL**: https://apify.com/crawlerbros/reverb-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 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

## Reverb Scraper

Extract music gear listings from [Reverb.com](https://reverb.com) — the world's largest online marketplace for buying and selling new, used, and vintage musical instruments and gear. Collect listing details including price, condition, seller info, photos, and shipping costs at scale.

### What You Can Scrape

- **Search by keyword** — find guitars, pedals, amps, drums, or any gear using any search term
- **Enrich specific listings** — provide listing URLs to extract full details for individual items
- **Scrape seller/shop pages** — collect all active listings from a specific shop or dealer

### Output Fields

Each extracted listing contains:

| Field | Type | Description |
|---|---|---|
| `listingId` | string | Unique Reverb listing identifier |
| `title` | string | Full listing title |
| `description` | string | Full item description (may contain HTML) |
| `price` | number | Listed price (numeric) |
| `currency` | string | Currency code (e.g. `USD`) |
| `condition` | string | Item condition label |
| `brand` | string | Instrument brand / manufacturer |
| `year` | integer | Year of manufacture (if available) |
| `category` | string | Product category (e.g. `electric-guitars`) |
| `listingUrl` | string | Direct URL to the listing on Reverb |
| `photos` | array | List of photo URLs for the listing |
| `sellerName` | string | Shop / seller name |
| `sellerUrl` | string | Seller's Reverb shop URL |
| `sellerLocation` | string | Seller's location (city, state, country) |
| `sellerRating` | number | Seller rating as a percentage (0–100) |
| `offersEnabled` | boolean | Whether the seller accepts offers |
| `shippingPrice` | number | US shipping cost in USD (0 = free) |
| `recordType` | string | Always `"listing"` |
| `scrapedAt` | string | ISO 8601 UTC timestamp of extraction |

### Input Options

| Field | Type | Description |
|---|---|---|
| `mode` | select | `searchListings`, `byListingUrls`, or `bySellerUrls` |
| `searchQuery` | string | Keyword to search (required for `searchListings` mode) |
| `listingUrls` | array | Listing URLs to enrich (required for `byListingUrls` mode) |
| `sellerUrls` | array | Seller/shop URLs (required for `bySellerUrls` mode) |
| `condition` | array | Filter by one or more conditions |
| `minPrice` | number | Minimum price in USD |
| `maxPrice` | number | Maximum price in USD |
| `sortBy` | select | `relevance`, `price_asc`, `price_desc`, `listing_newest` |
| `maxItems` | integer | Maximum listings to extract (1–5000, default 20) |

#### Condition Values

| Value | Label |
|---|---|
| `brand-new` | Brand New |
| `mint` | Mint |
| `excellent` | Excellent |
| `very-good` | Very Good |
| `good` | Good |
| `fair` | Fair |
| `poor` | Poor |
| `non-functioning` | Non-Functioning |

### Example Inputs

#### Search for vintage Fender guitars under $2,000

```json
{
  "mode": "searchListings",
  "searchQuery": "fender stratocaster vintage",
  "maxPrice": 2000,
  "condition": ["excellent", "very-good", "good"],
  "sortBy": "price_asc",
  "maxItems": 50
}
````

#### Enrich specific listing URLs

```json
{
  "mode": "byListingUrls",
  "listingUrls": [
    "https://reverb.com/item/12345-fender-stratocaster-1968",
    "https://reverb.com/item/67890-gibson-les-paul-standard"
  ]
}
```

#### Scrape all listings from a seller

```json
{
  "mode": "bySellerUrls",
  "sellerUrls": [
    "https://reverb.com/shop/revolution-guitarworks"
  ],
  "maxItems": 200
}
```

### Use Cases

- **Price research** — compare prices across condition grades and sellers for any instrument
- **Market analysis** — track pricing trends for specific brands, models, or gear categories
- **Dealer monitoring** — watch a competitor's or partner's shop inventory
- **Vintage gear hunting** — find rare or collectible instruments matching specific criteria
- **Deal alerts** — export results and filter for bargains in any category
- **Reseller sourcing** — identify underpriced listings for flipping

### FAQ

**Does this require a Reverb account or login?**
No. The scraper accesses Reverb's public API — no account, cookies, or authentication is needed.

**What is the maximum number of listings I can extract?**
The `maxItems` input accepts up to 5,000 listings per run. For larger data sets, run multiple times with different search queries or page offsets.

**Can I filter by price and condition at the same time?**
Yes. `minPrice`, `maxPrice`, and `condition` filters can all be used together. Listings must satisfy all active filters to be included.

**What does `shippingPrice: 0` mean?**
It means the seller offers free shipping to the US. A `null` or missing field means the shipping cost is unknown (e.g. local-only pickup or international only).

**Why might some fields be missing from a result?**
Fields like `year`, `sellerRating`, `shippingPrice`, and `description` are optional on Reverb — not every seller fills them in. The scraper only includes fields when Reverb returns them.

**Can I scrape seller reviews or feedback?**
Not in the current version. The scraper focuses on active listings. Seller feedback count is not directly extracted, though `sellerRating` (as a percentage) is available.

**Is this compliant with Reverb's terms?**
This scraper accesses Reverb's public, unauthenticated API endpoints — the same data served to web browsers. Always review Reverb's terms of service for your specific use case.

**What is the `recordType: "error"` entry in the dataset?**
When an invalid or unresolvable URL is provided (in `byListingUrls` or `bySellerUrls` modes), an error record is written to the dataset with the original URL and a reason string, so you can identify and fix bad inputs.

**What sort options are available?**

- `relevance` — Reverb's default relevance ranking
- `price_asc` — cheapest first
- `price_desc` — most expensive first
- `listing_newest` — most recently listed first

Sort only applies to `searchListings` mode.

# Actor input Schema

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

What to fetch. Use `searchListings` to search by keyword, `byListingUrls` to enrich specific listings, or `bySellerUrls` to scrape all listings from a seller/shop.

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

Keyword search term (mode=searchListings). Example: `guitar`, `fender stratocaster`, `vintage amp`.

## `listingUrls` (type: `array`):

List of Reverb listing URLs to enrich. Example: `https://reverb.com/item/12345-some-guitar`.

## `sellerUrls` (type: `array`):

List of Reverb shop/seller page URLs. Example: `https://reverb.com/shop/my-guitar-shop`. The scraper will collect all active listings from each shop.

## `condition` (type: `array`):

Filter listings to these condition slug(s). Leave empty to include all conditions. Allowed values: brand-new, mint, excellent, very-good, good, fair, poor, non-functioning.

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

Only include listings priced at or above this value.

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

Only include listings priced at or below this value.

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

Sort order for search results (mode=searchListings only).

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

Maximum number of listings to extract. Default is 20.

## Actor input object example

```json
{
  "mode": "searchListings",
  "searchQuery": "guitar",
  "listingUrls": [],
  "sellerUrls": [],
  "condition": [],
  "sortBy": "relevance",
  "maxItems": 5
}
```

# Actor output Schema

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

Dataset containing all scraped Reverb.com listings.

# 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": "searchListings",
    "searchQuery": "guitar",
    "listingUrls": [],
    "sellerUrls": [],
    "sortBy": "relevance",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/reverb-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": "searchListings",
    "searchQuery": "guitar",
    "listingUrls": [],
    "sellerUrls": [],
    "sortBy": "relevance",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/reverb-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": "searchListings",
  "searchQuery": "guitar",
  "listingUrls": [],
  "sellerUrls": [],
  "sortBy": "relevance",
  "maxItems": 5
}' |
apify call crawlerbros/reverb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reverb Music Gear Marketplace Scraper",
        "description": "Scrape Reverb.com the world's largest music gear marketplace. Search listings by keyword, condition, and price, or bulk-enrich specific listing URLs. Extracts title, price, condition, brand, photos, seller info, shipping, and more.",
        "version": "1.0",
        "x-build-id": "GjYGdAsFXHACCGYQf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~reverb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-reverb-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~reverb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-reverb-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~reverb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-reverb-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": [
                            "searchListings",
                            "byListingUrls",
                            "bySellerUrls"
                        ],
                        "type": "string",
                        "description": "What to fetch. Use `searchListings` to search by keyword, `byListingUrls` to enrich specific listings, or `bySellerUrls` to scrape all listings from a seller/shop.",
                        "default": "searchListings"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword search term (mode=searchListings). Example: `guitar`, `fender stratocaster`, `vintage amp`."
                    },
                    "listingUrls": {
                        "title": "Listing URLs (mode=byListingUrls)",
                        "type": "array",
                        "description": "List of Reverb listing URLs to enrich. Example: `https://reverb.com/item/12345-some-guitar`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUrls": {
                        "title": "Seller / Shop URLs (mode=bySellerUrls)",
                        "type": "array",
                        "description": "List of Reverb shop/seller page URLs. Example: `https://reverb.com/shop/my-guitar-shop`. The scraper will collect all active listings from each shop.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "condition": {
                        "title": "Condition filter",
                        "type": "array",
                        "description": "Filter listings to these condition slug(s). Leave empty to include all conditions. Allowed values: brand-new, mint, excellent, very-good, good, fair, poor, non-functioning.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Only include listings priced at or above this value."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Only include listings priced at or below this value."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "listing_newest"
                        ],
                        "type": "string",
                        "description": "Sort order for search results (mode=searchListings only).",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to extract. Default is 20.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
