# Reverb Used Gear New Listings & Deal Alert (`superslowsloth/reverb-listings`) Actor

Newest Reverb used music gear listings for any search terms, one flat row each: title, price in USD, condition, shop, make, model, year, finish, category, photo, shipping, price drop, URL. Newest-first or by price, with condition and price filters.

- **URL**: https://apify.com/superslowsloth/reverb-listings.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.26 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Used Gear New Listings & Deal Alert

Search [Reverb](https://reverb.com), the marketplace for used and new music
gear, for one or more terms and get one flat row per listing: title, price in
US dollars, condition, shop, make, model, year, finish, category, photo,
shipping, price drop and the listing URL. Newest first by default, so a
scheduled run is a **Reverb new-listing alert**; the price sorts, condition
filter and price band make it a used-gear deal watch for guitars, pedals,
synths, amps and drums.

No account, no API key, no login, no browser. One request returns 50 listings.

### Input

| Field | Notes |
|---|---|
| `queries` | One or more search terms, one per line. Required. A listing found by two terms is returned once, under the first. |
| `maxItems` | Listings to read per search term (default 100, up to 2,500). Reverb serves 50 pages of 50 per search however many matches it reports, so a broader search needs a narrower term, a condition or a price band. |
| `sort` | `newest` (default), `relevance`, `price-asc`, `price-desc`. |
| `conditions` | Only these conditions: `new`, `used` (Reverb's umbrella for mint to fair), `mint`, `excellent`, `very-good`, `good`, `fair`, `non-functioning`, `b-stock`. Empty means all. |
| `minPrice`, `maxPrice` | Asking-price band in US dollars, inclusive, either end optional. |
| `proxyConfiguration` | Apify proxy by default. |

#### About "newest first"

This is Reverb's `published_at` descending order, so a listing sits where it
was last published. There is no "oldest first" option: Reverb ignores that sort
and returns its default order, so the actor does not offer it.

#### About the price sorts

`price-asc` and `price-desc` are Reverb's own price ordering. Rows priced in
another currency are converted to dollars for `price`, so a converted row can
sit slightly out of dollar order (measured: $41,752.49 listed above $41,795.00
in a high-to-low sort).

#### About the price band

Reverb converts a listing priced in another currency to dollars itself, using
its own rate. The band is applied by Reverb, not by the actor, and an edge row
can land a fraction of a percent outside it (a listing priced in euros came
back at $4,934.80 for a $5,000 minimum when measured).

### Output

| Field | Notes |
|---|---|
| `query` | The search term that first found this listing. |
| `listing_id`, `url` | Reverb's numeric id and the absolute `https://reverb.com/item/...` link. |
| `title` | As the seller wrote it. |
| `price`, `currency` | The asking price as a float, and its currency. The actor asks Reverb for dollars, so `currency` is `USD` on every row. |
| `listing_currency` | The currency the seller priced the listing in (`USD`, `EUR`, `GBP`, `CAD`, `AUD`, `JPY` ...). When it is not `USD`, `price` is Reverb's conversion. In a measured sample of 900 listings, 26 percent were not priced in dollars. |
| `original_price`, `price_drop_percent` | Reverb's `original_price` and the percent of its "price drop" label. See below. |
| `condition`, `condition_slug` | Reverb's label (`Very Good`) and slug (`very-good`). |
| `published_at`, `created_at` | ISO 8601 in UTC (`2026-10-09T19:11:21Z`). Reverb sends the seller's local offset, which differs from row to row, so the actor puts them on one clock. |
| `shop_name` | The selling shop's display name. |
| `make`, `model`, `year`, `finish` | As the seller typed them. `year` is text (`1977`, `2013 - Present`, `New`); empty is null. `make` and `model` are free text and sometimes repeat the title. |
| `category`, `categories` | The first category (`Electric Guitars / Solid Body`) and every category the listing carries. |
| `photo_url` | The main photo, an 800 px rendition. Nothing is downloaded. |
| `offers_enabled` | True when the seller accepts offers. |
| `shipping_price`, `shipping_region` | The seller's first shipping rate in US dollars and the region it is for (`US_CON`, `GB`, `DE` ...), usually the seller's home region. Details below. |
| `state` | Reverb's listing state, `live` for what a search returns. |

#### Honest nulls

A field Reverb did not send is `null`, never `0` or `""`:

- `shipping_price` is null when the listing has **no shipping rate** (local
  pickup only) and when the rate is **calculated by the carrier at checkout**
  (Reverb sends no amount). In a measured sample of 900 listings that was 46
  and 125 listings. It is `0.0` only when Reverb states a zero rate, which is
  free shipping.
- `year` and `finish` are null when the seller left them empty (287 of 900
  listings had no year).
- `original_price` is null when Reverb sends none. It is also sent, equal to
  `price`, on listings that were never reduced, so a real price drop is
  `price_drop_percent` being set, or `original_price` above `price`.

#### Personal data

Titles and shop names are written by sellers and can hold names. They are
carried as Reverb publishes them; nothing is extracted from them.

### Pricing

Pay per event:

- **$0.002** per run (`actor-start`), charged only after your input is
  validated, so a run that fails on bad input costs nothing.
- **$0.00126** per listing row written (`listing-scraped`), i.e. $1.26 per
  1,000 listings.

### How it fetches

It calls the JSON API behind Reverb's own site (`api.reverb.com/api/listings`),
50 rows per request, with `Accept-Version: 3.0` (the API answers HTTP 400
without it) and `Accept: application/hal+json`. It also sends
`X-Display-Currency: USD` so prices do not change currency with the address the
run leaves from. Measured 2026-10-10: HTTP 200 from a plain connection, 45
consecutive pages with no rate limit. Apify datacenter proxy is the default; a
403, 429 or 5xx is treated as a refusal, the actor rotates to a fresh address
and retries.

Things worth knowing, all measured:

- **Result cap.** `total_pages` never exceeds 50, so one search returns at most
  2,500 listings. Pages beyond 50 are still answered, but they repeat listings
  from page 50 (34 of 50 measured), so the actor never reads them and logs when
  a term was cut off at the cap.
- **Filters are checked by the actor.** Reverb silently ignores a filter value
  it does not know (an unknown condition returns the unfiltered result set with
  HTTP 200), so the actor only sends the condition values listed above.
- **Counts move.** `total` changes between requests as listings are added and
  sold, so a walk can show a listing twice across a page boundary; it is
  returned once.

# Actor input Schema

## `queries` (type: `array`):

What you would type into Reverb's search box, one term per line (for example fender telecaster, boss ds-1 or moog subharmonicon). Each term is searched and read separately. A listing that two terms both find is returned once, under the first.

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

Read at most this many listings for each search term. Reverb serves 50 per request and never more than 50 pages (2,500 listings) per search, however many it reports finding, so values above 2500 are not accepted.

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

The order Reverb lists the results in. 'Newest first' orders by publication time and is the one for new-listing alerts. 'Relevance' is Reverb's own default order. The price sorts follow Reverb's own price ordering, so a listing converted from another currency can sit slightly out of dollar order.

## `conditions` (type: `array`):

Only listings in one of these conditions. Leave empty for every condition. 'Used (all grades)' is Reverb's own umbrella for mint, excellent, very good, good and fair; it excludes brand new and B-stock.

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

Lowest asking price to return, in US dollars, inclusive. Leave empty for no lower bound. Reverb converts listings priced in other currencies to dollars itself, so a row can land a fraction of a percent outside the band.

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

Highest asking price to return, in US dollars, inclusive. Leave empty for no upper bound. Use it, with a minimum, to read past the 2,500-listings-per-search window Reverb serves.

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

Apify proxy (automatic datacenter exits) is the default. Reverb sits behind Cloudflare; a refused request (403, 429) is retried from a fresh address, which is what the proxy is for.

## Actor input object example

```json
{
  "queries": [
    "fender telecaster"
  ],
  "maxItems": 100,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "queries": [
        "fender telecaster"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/reverb-listings").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 = {
    "queries": ["fender telecaster"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/reverb-listings").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 '{
  "queries": [
    "fender telecaster"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/reverb-listings --silent --output-dataset

```

## MCP server setup

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

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/iQzghTn3cCl5lKYYX/builds/kZ9oWCQIO3L58ghqS/openapi.json