# Reverb Scraper — Gear Listings, Prices, Condition & Sellers (`haketa/reverb-scraper`) Actor

Scrape the Reverb musical-instrument marketplace: guitars, amps, pedals, synths and pro audio with make, model, year, finish, condition, price, buyer price, shop & preferred-seller, category, shipping, description and photos. For gear resellers, shops, collectors and price research.

- **URL**: https://apify.com/haketa/reverb-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reverb Scraper — Musical Gear Listings, Prices, Condition, Sellers & Photos

[![Apify Actor](https://img.shields.io/badge/Apify%20Actor-Ready-orange?logo=apify)](https://apify.com/haketa/reverb-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-brightgreen.svg)](https://apify.com/haketa/reverb-scraper)
[![Data Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-blue.svg)](https://apify.com/haketa/reverb-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1000%2B%20Unlocked-success.svg)](https://apify.com/haketa/reverb-scraper)
[![Target](https://img.shields.io/badge/Target-Reverb.com-red.svg)](https://reverb.com)

**Extract rich musical instrument and gear marketplace data from Reverb without writing code or solving challenges.** This high-performance **Reverb Scraper** extracts live listings across electric guitars, acoustic guitars, vintage amplifiers, effects pedals, synthesizers, drum kits, microphones, and studio pro-audio equipment directly into **JSON, CSV, or Excel**.

Whether you are tracking vintage guitar valuations, sourcing underpriced gear to flip, benchmarking dealer inventories, or extracting 1,000+ listings across multiple search queries, this actor delivers clean, normalized marketplace intelligence instantly.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Platform** | Reverb Marketplace ([reverb.com](https://reverb.com)) |
| **Coverage Verticals** | Electric Guitars, Acoustics, Basses, Amps, Effects Pedals, Synths, Keyboards, Drums, Pro Audio & Recording Gear |
| **Data Extracted** | Make, Model, Build Year, Finish, Condition, Listing Price, Buyer Price, Seller Shop, Preferred Status, Shipping Rates, Description, High-Res Photos |
| **Pagination Support** | Automated multi-page traversal (50 listings per page) up to 1,000+ items across queries |
| **Search & Filtering** | Keywords, Brand (`make`), Category, Condition, Price Range, Year Range, Currency Normalization, Shipping Origin & Destination |
| **Proxy Requirement** | Apify Proxy datacenter rotation enabled by default |
| **Export Formats** | Dataset (JSON, CSV, XML, Excel), Key-Value Store (`OUTPUT`), Apify REST API |
| **Average Run Time** | ~15–35 seconds for standard prefill runs (~60–100 items) |

***

### 🔎 Why scrape Reverb?

[Reverb](https://reverb.com) is the world's leading secondary marketplace for musical gear. It connects independent musicians, vintage collectors, regional guitar shops, and international gear dealers.

Because gear valuations fluctuate heavily based on cosmetic condition, production year, original finish, and brand provenance, having access to real-time structured marketplace listings is critical for making informed buying, trading, and inventory pricing decisions.

#### Core Business Use Cases

- **Used Gear Resale & Arbitrage**: Spot mispriced guitars, vintage amplifiers, and rare stompboxes listed below prevailing secondary market rates.
- **Retail & Pawn Pricing Intelligence**: Provide guitar shops, consignment boutiques, and pawnbrokers with real-time price floor and ceiling benchmarks.
- **Vintage Instrument Valuation**: Track market availability and asking prices for vintage instruments (e.g. 1950s–1970s Fender Stratocasters, Gibson Les Pauls, Martin acoustics).
- **Competitor Catalog Monitoring**: Track preferred seller shop inventories, new listing velocities, and promotional markdown schedules.
- **E-Commerce Catalog Enrichment**: Enrich musical retail catalogs with standardized brand names, model specifications, product category trees, and gallery photos.
- **Market Supply Research**: Analyze macroeconomic supply volume, price distribution, and regional origin shifts across major audio hardware categories.

***

### ✨ Key Features & Capabilities

- **Keyword & Filtered Browse Modes**: Search by explicit keywords (e.g. `"Stratocaster"`, `"Tube Screamer"`, `"Minimoog"`) or browse entire categories by brand, condition, and price without keywords.
- **Multi-Query Support**: Pass multiple search terms in a single job; listings are merged and deduplicated automatically.
- **Comprehensive Condition Mapping**: Filter by precise grading tiers (`Brand New`, `B-Stock`, `Mint`, `Excellent`, `Very Good`, `Good`, `Fair`, `Poor`, `Non Functioning`).
- **Currency Conversion**: Request listings converted to your target ISO currency (USD, EUR, GBP, CAD, AUD, JPY) for international price comparisons.
- **Full Listing Data in One Call**: Extracts prices, seller information, descriptions, and up to 12 high-resolution image URLs in a single pass without secondary item detail latency.
- **Seller Reputation Insights**: Identify Reverb Preferred Sellers, independent gear boutiques, and local shop locations.
- **Deep Pagination & Zero Duplicate Guarantee**: Automatically pages through catalog results and indexes every listing by unique internal ID.

***

### 📥 Input Parameters

All parameters are optional. Running the actor with an empty configuration defaults to popular gear searches with prefilled settings.

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | Array | `["stratocaster"]` | Keywords to search (e.g., `["stratocaster", "les paul", "pedal"]`). Multiple queries run sequentially. |
| `make` | Array | `[]` | Filter by manufacturer/brand names (e.g., `["Fender", "Gibson", "Boss", "Moog"]`). |
| `productType` | String | `""` | Top-level product category slug (e.g., `electric-guitars`, `effects-and-pedals`, `amps`, `keyboards-and-synths`). |
| `category` | String | `""` | Sub-category slug (e.g., `solid-body`, `overdrive-and-boost`, `tube-combos`). |
| `condition` | Select | `""` | Filter by item condition rating (e.g., `mint`, `excellent`, `very-good`). |
| `priceMin` | Integer | `null` | Minimum listing price threshold. |
| `priceMax` | Integer | `null` | Maximum listing price threshold. |
| `yearMin` | String | `""` | Earliest manufacturing build year (e.g., `"1965"`). |
| `yearMax` | String | `""` | Latest manufacturing build year (e.g., `"1979"`). |
| `currency` | String | `""` | Target ISO currency code for price conversion (e.g., `"USD"`, `"EUR"`, `"GBP"`). |
| `itemRegion` | String | `""` | Item physical origin country/region code (e.g., `"US"`, `"GB"`, `"DE"`, `"JP"`). |
| `shipsTo` | String | `""` | Filter listings that ship to a specific country code (e.g., `"US"`). |
| `preferredSellerOnly` | Boolean | `false` | When `true`, retains only listings from Reverb Preferred Sellers. |
| `freeShippingOnly` | Boolean | `false` | When `true`, filters for listings offering free shipping. |
| `acceptsOffersOnly` | Boolean | `false` | When `true`, filters for listings accepting buyer offers. |
| `sort` | Select | `""` | Sorting order (`"price\|asc"`, `"price\|desc"`, `"created_at\|desc"`, or relevance). |
| `maxItems` | Integer | `0` | Maximum listings to extract. Set to `0` for unlimited automatic pagination. |
| `maxPagesPerSearch` | Integer | `0` | Page budget cap per query. Set to `0` for unlimited automatic pagination. |
| `token` | String | `""` | Optional personal Reverb API token to expand rate-limit headroom. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Apify Proxy configuration. Datacenter proxies provide optimal throughput. |

***

### 📤 Output Data Fields

Every record returned by the scraper represents a live marketplace listing. The fields are standardized into clear data types.

#### 🎸 Gear Identity & Specifications

| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | String | 🟢 High | Unique Reverb listing identifier |
| `title` | String | 🟢 High | Full listing display title |
| `make` | String | 🟢 High | Brand or manufacturer name (e.g. Fender, Gibson, Roland) |
| `model` | String | 🟢 High | Specific instrument or gear model name |
| `finish` | String | 🟡 Conditional | Exterior finish, lacquer, or colorway |
| `year` | String | 🟡 Conditional | Manufacturing year or vintage decade |
| `category` | String | 🟢 High | Primary instrument category classification |
| `categories` | Array | 🟢 High | Complete hierarchical taxonomy category breadcrumbs |
| `sku` | String | 🟡 Conditional | Seller or manufacturer stock-keeping unit |

#### 💰 Pricing & Commercial Terms

| Field | Type | Coverage | Description |
|---|---|---|---|
| `price` | String | 🟢 High | Formatted display price string with currency symbol |
| `priceAmount` | Number | 🟢 High | Extracted numeric listing price |
| `currency` | String | 🟢 High | ISO currency code (e.g. USD, EUR, GBP) |
| `buyerPrice` | String | 🟡 Conditional | Estimated total purchase price including estimated taxes |
| `offersEnabled` | Boolean | 🟢 High | Whether the seller accepts counteroffers |
| `auction` | Boolean | 🟢 High | Indicates if the listing is an auction format |
| `inventory` | Number | 🟢 High | Total units currently available in stock |
| `state` | String | 🟢 High | Listing state (`live`, `ended`, `sold`) |

#### 🔍 Condition & Authenticity

| Field | Type | Coverage | Description |
|---|---|---|---|
| `condition` | String | 🟢 High | Human-readable condition rating (e.g. Mint, Excellent, Good) |
| `conditionSlug` | String | 🟢 High | Normalized condition slug for algorithmic filtering |
| `description` | String | 🟢 High | Full plain-text seller description and condition notes |

#### 🏪 Seller & Fulfillment Details

| Field | Type | Coverage | Description |
|---|---|---|---|
| `shopName` | String | 🟢 High | Name of the seller store or individual seller |
| `shopSlug` | String | 🟢 High | URL identifier slug for the seller shop |
| `shopId` | String | 🟢 High | Unique numerical seller shop ID |
| `preferredSeller` | Boolean | 🟢 High | Verified Reverb Preferred Seller badge status |
| `freeExpeditedShipping` | Boolean | 🟢 High | Free expedited shipping indicator |
| `shippingRate` | String | 🟡 Conditional | Primary standard domestic shipping fee |
| `originRegion` | String | 🟡 Conditional | Seller dispatch country or geographic territory |

#### 📸 Imagery & Web Links

| Field | Type | Coverage | Description |
|---|---|---|---|
| `photo` | String | 🟢 High | Primary featured high-resolution listing photograph |
| `photos` | Array | 🟢 High | Array of up to 12 full-resolution gallery image URLs |
| `url` | String | 🟢 High | Canonical web URL to the live listing page on Reverb |
| `scrapedAt` | String | 🟢 High | ISO 8601 scrape completion timestamp |

***

### 💻 Sample Output (JSON)

```json
{
  "id": "84729104",
  "title": "Fender American Professional II Stratocaster - Olympic White with Rosewood Fingerboard",
  "make": "Fender",
  "model": "American Professional II Stratocaster",
  "finish": "Olympic White",
  "year": "2023",
  "category": "Solid Body",
  "categories": [
    "Electric Guitars",
    "Solid Body"
  ],
  "sku": "0113900705",
  "price": "$1,499.00",
  "priceAmount": 1499.00,
  "currency": "USD",
  "buyerPrice": "$1,626.42",
  "offersEnabled": true,
  "auction": false,
  "inventory": 1,
  "state": "live",
  "condition": "Mint",
  "conditionSlug": "mint",
  "shopName": "Chicago Vintage Guitars",
  "shopSlug": "chicago-vintage-guitars",
  "shopId": "12984",
  "preferredSeller": true,
  "freeExpeditedShipping": true,
  "shippingRate": "Free",
  "originRegion": "US",
  "description": "Mint condition Fender Am Pro II Strat in Olympic White. Includes original hardshell case, certificate of authenticity, and case candy. Flawless frets and setup.",
  "photo": "https://images.reverb.com/image/upload/s--ABC123--/f_auto,t_large/v1700000000/listing.jpg",
  "photos": [
    "https://images.reverb.com/image/upload/s--ABC123--/f_auto,t_large/v1700000000/listing_1.jpg",
    "https://images.reverb.com/image/upload/s--DEF456--/f_auto,t_large/v1700000000/listing_2.jpg"
  ],
  "url": "https://reverb.com/item/84729104-fender-american-professional-ii-stratocaster-olympic-white",
  "scrapedAt": "2026-11-10T13:42:00.000Z"
}
```

```json
{
  "id": "78329145",
  "title": "Boss CE-2 Chorus Vintage 1982 Black Label Made in Japan",
  "make": "Boss",
  "model": "CE-2 Chorus",
  "finish": "Blue",
  "year": "1982",
  "category": "Chorus and Flange",
  "categories": [
    "Effects and Pedals",
    "Chorus and Flange"
  ],
  "price": "$220.00",
  "priceAmount": 220.00,
  "currency": "USD",
  "offersEnabled": true,
  "auction": false,
  "inventory": 1,
  "state": "live",
  "condition": "Very Good",
  "conditionSlug": "very-good",
  "shopName": "Tokyo Tone Vault",
  "shopSlug": "tokyo-tone-vault",
  "shopId": "58921",
  "preferredSeller": true,
  "freeExpeditedShipping": false,
  "shippingRate": "$18.00",
  "originRegion": "JP",
  "description": "Original MIJ Black Label CE-2 Chorus pedal. Fully tested and operational with classic lush analog modulation. Minor paint chips consistent with age.",
  "photo": "https://images.reverb.com/image/upload/s--XYZ789--/f_auto,t_large/v1700000000/ce2.jpg",
  "photos": [
    "https://images.reverb.com/image/upload/s--XYZ789--/f_auto,t_large/v1700000000/ce2_front.jpg",
    "https://images.reverb.com/image/upload/s--XYZ789--/f_auto,t_large/v1700000000/ce2_back.jpg"
  ],
  "url": "https://reverb.com/item/78329145-boss-ce-2-chorus-1982-black-label",
  "scrapedAt": "2026-11-10T13:42:02.000Z"
}
```

***

### 🚀 How to Run Reverb Scraper

#### Option 1: Apify Console

1. Open **Reverb Scraper** on Apify Store.
2. Enter desired search keywords (e.g. `Telecaster`, `Moog`, `Klon`) or specify make/model filters.
3. Configure target price range, build year, or condition grading as needed.
4. Click **Start** and monitor incoming items in the real-time execution log.
5. Export clean datasets via the **Export** tab in CSV, JSON, or Excel.

#### Option 2: Apify REST API

Trigger runs programmatically from any external application:

```bash
curl --request POST \
  --url "https://api.apify.com/v2/acts/haketa~reverb-scraper/runs?token=YOUR_API_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "searchTerms": ["fender stratocaster", "gibson les paul"],
    "condition": "excellent",
    "maxItems": 200,
    "sort": "price|asc"
  }'
```

#### Option 3: Python Client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "searchTerms": ["vintage synth"],
    "make": ["Roland", "Korg", "Yamaha"],
    "yearMax": "1989",
    "maxItems": 150
}

run = client.actor("haketa/reverb-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} - {item['price']} - {item['shopName']}")
```

#### Option 4: JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('haketa/reverb-scraper').call({
    searchTerms: ['boss pedal'],
    condition: 'mint',
    maxItems: 100,
    sort: 'price|asc',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items, ['title', 'price', 'condition', 'shopName']);
```

***

### 📈 Pagination Architecture & Scale

Reverb partitions marketplace search listings across paginated API cursors delivering 50 listings per response. To ensure frictionless extraction across extensive catalogs:

1. **Multi-Query Orchestration**: When multiple `searchTerms` are specified, the scraper iterates through each keyword sequentially without cross-query contamination.
2. **Deep Page Traversal**: The pagination loop advances page numbers until the catalog is exhausted, reaching your designated `maxPagesPerSearch` budget or aggregate `maxItems` quota.
3. **In-Memory ID Deduplication**: Every incoming listing is evaluated against a global `Set` of known Reverb IDs. Repetitive items across overlapping queries are automatically filtered out.
4. **Adaptive Rate-Limit Mitigation**: Apify Proxy rotates IP origins seamlessly with exponential backoff on HTTP 429 status codes, preserving stability during large scraping sessions.
5. **High-Volume Pagination**: Set `maxItems: 1000` or higher to pull large brand collections or complete category selections effortlessly.

***

### 🛠️ Step-by-Step Integration Guides

#### Connecting with Google Sheets & Zapier

1. Navigate to the **Integrations** tab of your actor on Apify Console.
2. Select **Zapier** or **Make (Integromat)**.
3. Choose the trigger event: **Actor Run Succeeded**.
4. Map the dataset fields: `title`, `make`, `model`, `priceAmount`, `condition`, and `url` to your Google Sheet columns.
5. Turn on the Zap to automate lead enrichment every time a scrape finishes.

#### Setting Up Webhook Alerts

You can trigger downstream HTTP endpoints automatically when the actor completes:

1. Go to **Actor Settings** > **Webhooks**.
2. Add a new Webhook with event **Run succeeded**.
3. Point the target URL to your webhook handler or serverless function.
4. Payload includes run details and a direct download link to the fresh dataset.

***

### 💡 Best Practices & Pro Tips

- **Resale Margin Optimization**: Filter by exact `make`, `model`, and `condition`, then apply `sort: "price|asc"` to immediately identify the prevailing market floor price.
- **Spot Rare Vintage Finds**: Set `yearMax: "1975"` and specify `category: "solid-body"` to monitor pre-CBS and golden-era vintage guitars.
- **Normalize Currency for Cross-Border Sourcing**: If you source gear from international sellers, specify `currency: "USD"` to evaluate comparable landing costs across US, European, and Japanese listings.
- **Browse Without Keywords**: To survey an entire brand without limiting yourself to specific model keywords, leave `searchTerms` empty and provide `make: ["Gibson"]` and `productType: "electric-guitars"`.

***

### ❓ Frequently Asked Questions

#### Do I need a Reverb account or API token?

No. This scraper operates on publicly accessible marketplace endpoints. A personal Reverb access token is completely optional and only needed if you wish to expand default rate-limit ceilings.

#### Can I scrape sold items and historical price guide charts?

Reverb officially deprecated and removed its public Price Guide historical transaction endpoints. Consequently, this actor extracts real-time active listings, allowing you to establish current asking prices and market supply floors.

#### Are datacenter proxies sufficient?

Yes. Apify datacenter proxies work reliably with Reverb's infrastructure. Intelligent IP rotation ensures uninterrupted requests without requiring costly residential proxies.

#### Can I run recurring price monitoring?

Yes. Use Apify Schedules to run the scraper daily or weekly. You can track new listings, detect price drops, and monitor inventory turnover automatically.

***

### 🔗 Related Scrapers & Marketplace Tools

- [Discogs Scraper](https://apify.com/haketa/discogs-scraper) — Vinyl records, CDs, cassettes, and marketplace pricing.
- [Poshmark Scraper](https://apify.com/haketa/poshmark-scraper) — Fashion apparel, shoes, and secondary luxury goods.
- [Vinted Scraper](https://apify.com/haketa/vinted-scraper) — European secondhand clothing and accessory marketplace.
- [Steam Game & Review Scraper](https://apify.com/haketa/steam-game-scraper) — PC video game pricing, discounts, and user reviews.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ Deep Pagination**: Removed restrictive 50-page maximum caps; pagination now seamlessly continues across extensive catalog queries governed by `maxItems`.
- **Fast Prefill Execution**: Optimized prefill configuration to extract 60 listings in ~15–25 seconds.
- **Standardized Schema**: Set `maxPagesPerSearch` and `maxItems` to `0` (unlimited auto-pagination) with `minimum: 0`.
- **Enhanced Data Normalization**: Improved numeric price extraction and hierarchical category breadcrumb parsing.
- **Documentation Overhaul**: Added visual architecture breakdowns, integration workflows, and comprehensive field coverage indicators.

#### v1.1 (2026-08)

- Added multi-currency conversion support across all standard ISO currency codes.
- Introduced fine-grained condition slugs and Reverb Preferred Seller verification badges.
- Improved proxy rotation resilience on HTTP 429 status codes.

#### v1.0 (2026-05)

- Initial release with keyword and filter-based gear discovery.
- In-memory listing deduplication and KVS `OUTPUT` sync.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/reverb-scraper/changelog.md

# Actor input Schema

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

Keywords to search (e.g. "stratocaster", "ts808", "moog"). Multiple terms run in one job. Leave empty to browse by the filters below (e.g. all Gibson electric guitars).

## `make` (type: `array`):

Filter by brand(s), e.g. "Fender", "Gibson", "Boss". Multiple brands allowed.

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

Top-level type slug, e.g. electric-guitars, acoustic-guitars, bass-guitars, effects-and-pedals, amps, keyboards-and-synths, pro-audio, drums.

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

Finer category slug (optional), e.g. solid-body, overdrive-and-boost, combos. See /api/categories/flat.

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

Filter by item condition.

## `priceMin` (type: `integer`):

Minimum price in the listing/convert currency (optional).

## `priceMax` (type: `integer`):

Maximum price (optional).

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

Earliest build year, e.g. 1960 (optional).

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

Latest build year, e.g. 1979 (optional).

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

Convert prices to this ISO currency, e.g. USD, EUR, GBP (optional).

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

Only items located in this region/country code, e.g. US, GB, DE (optional).

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

Only items that ship to this country code, e.g. US, GB (optional).

## `preferredSellerOnly` (type: `boolean`):

Only listings from Reverb Preferred Sellers.

## `freeShippingOnly` (type: `boolean`):

Only listings with free shipping.

## `acceptsOffersOnly` (type: `boolean`):

Only listings that accept offers.

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

Result order.

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

Optional Reverb personal access token to raise the rate limit. Not required.

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

Maximum listings across all searches. 0 = no limit.

## `maxPagesPerSearch` (type: `integer`):

Maximum pages to fetch per search term (50 listings per page). Set to 0 for unlimited automatic pagination governed by maxItems.

## `proxyConfiguration` (type: `object`):

Apify Proxy. Datacenter is enough; rotating IPs each get their own Reverb rate-limit budget.

## Actor input object example

```json
{
  "searchTerms": [
    "stratocaster"
  ],
  "condition": "",
  "preferredSellerOnly": false,
  "freeShippingOnly": false,
  "acceptsOffersOnly": false,
  "sort": "",
  "maxItems": 60,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Reverb listing ID

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

Listing title

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

Brand

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

Model

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

Finish/colour

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

Build year

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

Condition

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

Display price

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

Numeric price

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

Currency

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

Buyer price (with tax)

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

Units available

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

Accepts offers

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

Is auction

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

live / sold / ended

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

Primary category

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

Seller shop name

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

Preferred seller flag

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

Free expedited shipping

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

First shipping rate

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

SKU

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

Description (text)

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

Published timestamp

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

Main photo URL

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

Reverb listing URL

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

ISO timestamp

# 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": [
        "stratocaster"
    ],
    "maxItems": 60,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "searchTerms": ["stratocaster"],
    "maxItems": 60,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/reverb-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "stratocaster"
  ],
  "maxItems": 60,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/reverb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/reverb-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IXrqDV80J0wGPmPaF/builds/OnMV4faA0IaxWccgi/openapi.json