# Reverb Trending Gear Scraper (`parseforge/reverb-trending-gear-scraper`) Actor

Export Reverb demand data: sales in the last 30 and 90 days, price trend, sell-through and watchers per product. CSV, Excel, JSON or XML.

- **URL**: https://apify.com/parseforge/reverb-trending-gear-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.24 / 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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Reverb Scraper - Used Gear Listings, Prices & Demand

**Scrape Reverb used gear listings with the demand signals the marketplace hides: watchers, views and offer counts on every item.** Each row carries brand, model, build year, condition, price, seller rating and shipping, and the run can rank what it collected by how many people are watching. No login, no API key, no browser. Export to CSV, JSON, Excel, or XML.

Reverb closed its public Price Guide endpoint, and its search results never show you how much interest a listing has. This reads the marketplace API directly, adds the per-item demand numbers, and rebuilds model-level pricing from live listings: lowest new price, lowest used price, and how many of each are on sale right now.

| Who uses it | What they scrape Reverb for |
|---|---|
| Gear dealers and resellers | What is moving, at what price, and which listings are collecting watchers |
| Pricing analysts | Lowest new and used asking price per model, refreshed on a schedule |
| Instrument brands | How their models are priced and stocked against rivals on the used market |
| Marketplace researchers | Supply by category, seller quality, and how promotions move inventory |
| Collectors and buyers | Vintage gear by build year, condition and country, with the seller's rating attached |

### What it does

Six collections from Reverb's public API, all writing into one dataset and tagged by a `collection` field.

- 🎸 **Listings (38 fields):** title, brand, model, finish, build year, condition, price and buyer price, currency, auction flag, inventory, categories, seller name, seller rating and feedback count, shipping regions and the US rate, photos, description, and the item URL.
- 👀 **Demand signals (opt-in, 13 more fields):** watchers, views, offer count, exact item location, videos, accepted payment methods, return policy and shipping policy.
- 🏪 **Seller profiles (opt-in, 8 more fields):** shop slug, country, shop type, website, vacation status, and the quick-shipper and quick-responder badges.
- 💵 **Products:** Reverb's canonical model pages with the lowest new price, the lowest used price, and how many new and used units are listed.
- 🗂 **Categories, curated sets, sales and news:** the 14 root types and 320 categories with optional live counts, the collections Reverb is featuring, every running promotion with its coupon code and end date, and Reverb News posts.

### What you can do with Reverb data

**📈 Find what is actually trending.**

Turn on the demand signals and set `rankBy` to `watches` or `views`. The run collects the slice you asked for, then writes it back ordered, with a `rankPosition` on every row.

**💰 Build your own price guide.**

Run the `products` collection for a brand or a gear type and get the lowest new and used asking price per model, with the number of listings behind each figure, so you can see how deep or thin that market is.

**🏷 Price your own inventory.**

Filter listings by brand, build year and condition, and compare them against the live asks for the same gear, seller rating and shipping cost included.

**🔔 Watch the promotions.**

The `sales` collection lists every live Reverb promotion with its coupon code, dates and how many listings take part. Feed a sale ID back into the listing filter to see exactly which gear it covers.

### Why choose this scraper

| | What you get |
|---|---|
| **Demand signals per item** | Watchers, views and offers on each listing, the numbers that show what buyers actually want. |
| **Six collections, one run** | Listings, model pages, categories, curated sets, sales and news, sharing a single item budget. |
| **Filters that were measured** | Reverb ignores a filter it does not recognise instead of rejecting it. Every filter and sort here was tested against result counts, and the ones that do nothing were left out of the schema. |
| **Past the 20,000-item window** | Reverb serves at most 20,000 items per query. Ask for more and the run splits the query into 13 price bands and deduplicates across them. |
| **Model-level pricing** | Lowest new and used ask per canonical model, with listing counts, now that Reverb's public Price Guide endpoint is closed. |
| **Fast and light** | 2,000 listings in 85 seconds on 512 MB, straight HTTP with no proxy and no browser. |

### How it compares

Reverb has more than a dozen scrapers on Apify and most of them return the same search-results fields: title, price, condition, seller name. The difference here is the second request per item. Watchers, views and offer counts only exist on the listing detail document, so a scraper that reads search results alone cannot rank by demand at any price, and the ones that do read details charge for them on every row instead of only when you ask.

| Actor | Users (30d) | Price per row | Demand signals | Collections |
|---|---|---|---|---|
| `parseforge/reverb-trending-gear-scraper` | new | $0.005, extras billed separately | Watchers, views, offers, rank | 6 |
| `devilscrapes/reverb-sold-listings` | 2 | $0.005 plus $0.20 per run | No | 1 |
| `jungle_synthesizer/reverb-price-guide-used-gear-scraper` | 3 | $0.0005 plus $0.10 per run | No | 1 |
| `sashaebashu/reverb-scraper` | 2 | $0.002 | No | 1 |
| `automation-lab/reverb-musical-instruments-marketplace-scraper` | 1 | $0.005 per run start | No | 1 |

We are more expensive per row than the cheapest of them. What the difference buys is the demand data, the model-level pricing, and filters that were verified one by one against Reverb's own result counts.

### What a listing looks like

One real row from a verified run, with the demand signals and the seller profile turned on:

```json
{
  "collection": "listings",
  "listingId": "93701684",
  "title": "Gibson Guitar Of The Week #1 SG Supreme Bass 2007 - Natural",
  "make": "Gibson",
  "model": "Guitar Of The Week #18 SG Supreme Bass",
  "finish": "Natural",
  "year": "2007",
  "condition": "Good",
  "conditionSlug": "good",
  "price": 1900,
  "priceCurrency": "USD",
  "priceDisplay": "$1,900",
  "buyerPrice": 1900,
  "listingCurrency": "USD",
  "isAuction": "No",
  "offersEnabled": "Yes",
  "inventory": 1,
  "state": "live",
  "categories": ["Bass Guitars / Short Scale", "Bass Guitars / 4-String"],
  "shopName": "Revolution GuitarWorks",
  "shopId": "159193",
  "shopIsPreferredSeller": "Yes",
  "shopFeedbackCount": 3535,
  "shopRatingPercentage": 0.9980582524271845,
  "shippingRegions": ["US_CON"],
  "freeExpeditedShipping": "No",
  "localPickupAvailable": "Yes",
  "createdAt": "2025-12-23T18:29:16-06:00",
  "publishedAt": "2025-12-23T18:32:19-06:00",
  "photoUrl": "https://rvb-img.reverb.com/i/s--OIGp9Fpj--/quality=medium-low,height=800,width=800,fit=contain/94b48f46-e6a2-4556-8606-a2d8a2792fff.jpg",
  "photoCount": 1,
  "description": "This Gibson SG Supreme Bass was the first of the Guitar of the Week series that went through 2007 with a maximum of 400 units produced...",
  "url": "https://reverb.com/item/93701684",
  "watches": 156,
  "views": 3375,
  "offerCount": 1,
  "location": "Ramsey, MN, US",
  "originCountryCode": "US",
  "handmade": "No",
  "soldAsIs": "No",
  "videoCount": 0,
  "comparisonShoppingPageId": 87327,
  "acceptedPaymentMethods": ["direct_checkout", "paypal", "paypal_pay_later"],
  "returnPolicy": "This product can be returned within 7 days of receipt.",
  "shopSlug": "rgw",
  "shopType": "business",
  "shopQuickShipper": "Yes",
  "scrapedAt": "2026-09-08T14:28:22.416Z"
}
```

A row never carries a literal null: withheld values come back as `Not Disclosed`, fields that do not apply as `N/A`, and booleans as `Yes` or `No`. A `products` row instead carries `newLowPrice`, `usedLowPrice`, `newListingCount`, `usedListingCount` and `totalListingCount` for one canonical model.

### Configure the run

Pick one or more `collections`. `maxItems` is the budget for the whole run: each collection takes an even share and whatever it does not use rolls over to the next one. The Input tab lists every parameter.

The 50 most watched used Stratocasters, ranked by demand:

```json
{ "collections": ["listings"], "query": "stratocaster", "condition": "used", "includeListingStats": true, "rankBy": "watches", "maxItems": 50 }
```

Price data for every Gibson model page:

```json
{ "collections": ["products"], "make": "Gibson", "maxItems": 500 }
```

Vintage amps built before 1970, listed in the US, with the seller profile attached:

```json
{ "collections": ["listings"], "productType": "amps", "yearMax": 1970, "itemRegion": "US", "includeShopProfiles": true, "maxItems": 300 }
```

### Pricing

Pay-per-event. The listing row costs **$0.005**, and the optional extra requests are billed as their own events, so a plain listing scrape never pays for enrichment it did not ask for.

| Event | Price | Charged |
|---|---|---|
| Run start | $0.005 | Once per run, capped at 1 GB so it is never multiplied |
| Listing | $0.005 | Per listing written, duplicates dropped before billing |
| Listing demand signals | $0.004 | Per listing detail fetched |
| Seller profile | $0.004 | Per shop fetched, once per shop per run |
| Model page | $0.005 | Per model row written |
| Category | $0.003 | Per category row written |
| Live listing count | $0.003 | Per category counted |
| Curated set | $0.003 | Per set row written |
| Sale | $0.003 | Per sale row written |
| Article | $0.003 | Per article row written |

| What you collect | Approximate cost |
|---|---|
| 100 listings | $0.51 |
| 1,000 listings | $5.01 |
| 1,000 listings with watchers and views | $9.01 |
| 10,000 listings | $50.01 |

Rates drop by up to 11% on higher Apify plans. New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 rows as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 rows per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Reverb Trending Gear Scraper](https://apify.com/parseforge/reverb-trending-gear-scraper?fpr=vmoqkp).
3. Pick your `collections`, add filters such as `query`, `make`, `productType` or `condition`, set `maxItems`, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Reverb through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/reverb-trending-gear-scraper"
```

Then prompt it in plain language:

- *"Find the 20 most watched used Les Pauls on Reverb right now and list their prices and sellers."*
- *"What is the lowest used price for a Fender American Professional II Stratocaster, and how many are listed?"*
- *"List every live Reverb sale with its coupon code and end date."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/reverb-trending-gear-scraper" to collect Reverb marketplace data. Input: { "collections": ["listings"], "query": "<keyword>", "make": "<brand>", "condition": "<used|new|all>", "includeListingStats": true, "rankBy": "watches", "maxItems": <n> }. It returns title, make, model, year, condition, price, seller name and rating, watchers, views, offer count and the item URL per listing. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why did I get far more results than my filter should return?**

Reverb ignores a filter it does not recognise rather than rejecting it, so a misspelled brand quietly widens the search to the whole catalogue. Check the log line that reports how Reverb read your query, for example `Reverb read the query as "Electric Guitars": 219811 listings`. Unsupported sort and condition values are blocked before the request; brand and category slugs are yours to spell.

**Why do I get fewer items than I asked for?**

Reverb serves at most 20,000 items per query. Above that the run splits the query into price bands automatically, but a narrow filter can still hold fewer items than your `maxItems`, and rows Reverb repeats across pages are dropped instead of billed.

**Why are watchers and views empty?**

They live on the listing detail document, not in search results. Turn on `includeListingStats`, or set `rankBy`, which turns it on for you.

**Why is `category` being ignored?**

Reverb only honours a sub-category together with a `productType`. Use `categoryUuid` to filter on its own; run the `categories` collection to get the UUIDs.

**Why is the run slow?**

Plain listings run at about 23 rows per second. Each demand-signal or seller-profile block adds one request per item, so a ranked run of 1,000 listings takes a few minutes. Lower `maxItems` or split the job into scheduled runs.

**A field stopped filling.**

Reverb changed its public API shape. Email us with your run ID so we can update the parser.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Reverb account or API key? | No. It reads Reverb's public API, so there is no OAuth app or token to manage. |
| Does it include the Reverb Price Guide? | Reverb closed that endpoint to the public. The `products` collection rebuilds the useful part from live listings: lowest new and used asking price per model, and how many are listed. |
| Can I get sold prices? | No. Reverb's public API exposes live listings, not completed sales. Watchers, views and offer counts are the demand signal it does expose. |
| How do I find what is trending? | Turn on `includeListingStats` and set `rankBy` to `watches` or `views`. Every row comes back with a `rankPosition`. |
| Can I scrape one seller's inventory? | Filter as you like and turn on `includeShopProfiles`, then filter the export by `shopName` or `shopSlug`. |
| How many items per run? | Free plan: 10. Paid: up to 1,000,000, subject to Reverb's 20,000-item window per query, which the run works around with price bands. |
| How fast is it? | 2,000 listings in 85 seconds on 512 MB in a verified run. Enrichment adds one request per item. |
| Does it use a proxy? | Only if it has to. Requests go out directly and the run falls back to Apify Proxy if the container IP is blocked. |
| Why are some fields "Not Disclosed"? | The seller did not publish that value. Rows never carry nulls, so withheld data says so and fields that do not apply say `N/A`. |
| Is this an official Reverb product? | No. It is unofficial and reads only public Reverb data. |

### Related actors

- [eBay Scraper](https://apify.com/parseforge/ebay-scraper?fpr=vmoqkp): listings and prices from the largest general marketplace.
- [Etsy Shop Products Scraper](https://apify.com/parseforge/etsy-scraper?fpr=vmoqkp): handmade and vintage listings with shop data.
- [Discogs Scraper](https://apify.com/parseforge/discogs-scraper?fpr=vmoqkp): records, releases and marketplace prices for music collectors.
- [Mercari Scraper](https://apify.com/parseforge/mercari-scraper?fpr=vmoqkp): second-hand listings and prices from Mercari.
- [Craigslist Listings Scraper](https://apify.com/parseforge/craigslist-scraper?fpr=vmoqkp): local classifieds for second-hand gear.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Reverb.com LLC. It collects only publicly available Reverb data. You are responsible for using the data in compliance with Reverb's terms and applicable laws, including GDPR, CCPA, and PIPL. Do not use it to identify, profile, or target individuals.

# Actor input Schema

## `collections` (type: `array`):

One or more collections. Rows from every collection land in the same dataset, tagged by the `collection` field. maxItems is the budget for the whole run: each collection gets an even share and whatever it does not use rolls over to the next one.

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

Total rows for the run, shared across the selected collections. Free Apify plans are capped at 10 rows as a preview. Reverb serves at most 20,000 items per marketplace query; ask for more and the query is automatically split into price bands to get past that window.

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

Free-text search over listings, for example "1959 les paul" or "tube screamer". Leave empty to browse everything.

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

Brand name as Reverb spells it, for example Fender, Gibson, Boss, Roland. An unknown brand is ignored by Reverb rather than rejected, so check the row count if you get more than you expected.

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

Top-level gear type slug, for example electric-guitars, acoustic-guitars, effects-and-pedals, amps, keyboards-and-synths, drums-and-percussion, pro-audio, bass-guitars, folk-instruments, home-audio, parts, accessories, band-and-orchestra, dj-and-lighting-gear.

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

Sub-category slug, for example solid-body or 5-string-or-more. Reverb only honours this together with a product type; run the "categories" collection to see every slug.

## `categoryUuid` (type: `string`):

Alternative to the two fields above: the category UUID from the "categories" collection. Works on its own.

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

Condition filter. "all" covers both new and used gear.

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

Lowest asking price to include, in US dollars.

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

Highest asking price to include, in US dollars.

## `yearMin` (type: `integer`):

Earliest build year to include, matched against the year Reverb has on the listing.

## `yearMax` (type: `integer`):

Latest build year to include, matched against the year Reverb has on the listing.

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

Two-letter country code of the seller's location, for example US, GB, DE, JP.

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

Two-letter country code the item can be shipped to.

## `handmade` (type: `boolean`):

Only gear Reverb flags as handmade.

## `freeShipping` (type: `boolean`):

Only listings that ship free.

## `preferredSeller` (type: `boolean`):

Only listings from sellers holding the Preferred Seller badge.

## `curatedSetId` (type: `integer`):

Only listings inside one of Reverb's featured sets. IDs come from the "curated-sets" collection.

## `saleId` (type: `integer`):

Only listings taking part in one live sale. IDs come from the "sales" collection.

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

Reverb accepts any string here and silently ignores the ones it does not know, so only the four orders that were measured to work are offered.

## `includeListingStats` (type: `boolean`):

Fetches each listing's detail page to add watchers, views, offer count, exact location, videos, payment methods and return policy. This is what makes a listing set rankable by demand.

## `includeShopProfiles` (type: `boolean`):

Adds the seller's slug, country, shop type, website, vacation status and quick-shipper/quick-responder badges. Each shop is fetched once per run even when it has many listings.

## `includeListingCounts` (type: `boolean`):

Fills listingCount on the "categories" collection with how many items are listed in that category right now. Curated sets always get their count; categories are opt-in because there are 320 of them.

## `rankBy` (type: `string`):

Orders the listings this run collected and writes a rankPosition on each row. Needs the demand signals above and turns them on automatically.

## `productQuery` (type: `string`):

Free-text search for the "products" collection, for example "stratocaster". Falls back to the listing search query when empty.

## `useApifyProxy` (type: `boolean`):

Reverb's API is reached directly, which is free and fast. Leave this on so the run can fall back to Apify Proxy (datacenter, then residential) if the container's IP gets blocked. Turning it off makes a blocked run fail instead.

## Actor input object example

```json
{
  "collections": [
    "listings"
  ],
  "maxItems": 20,
  "handmade": false,
  "freeShipping": false,
  "preferredSeller": false,
  "includeListingStats": false,
  "includeShopProfiles": false,
  "includeListingCounts": false,
  "rankBy": "none",
  "useApifyProxy": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `csv` (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 = {
    "collections": [
        "listings"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/reverb-trending-gear-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 = {
    "collections": ["listings"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/reverb-trending-gear-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 '{
  "collections": [
    "listings"
  ],
  "maxItems": 20
}' |
apify call parseforge/reverb-trending-gear-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/reverb-trending-gear-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/VobSnHqxaDfRzdT8p/builds/aFICm9EHvnzAoiWk0/openapi.json