# Reverb Music Gear and Sold Price Guide Scraper (`abotapi/reverb-scraper`) Actor

Scrape reverb.com music gear: guitars, amps, synths, pedals, drums and pro audio. Search live listings by brand, category, condition, price, year, region and shipping, or paste links. Uniquely returns the sold Price Guide per gear model: median, low, high and quartile realised prices.

- **URL**: https://apify.com/abotapi/reverb-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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

## Reverb Music Gear and Sold Price Guide Scraper

Pull music gear from Reverb (reverb.com), the marketplace for new, used and vintage guitars, amps,
synthesizers, pedals, drums and pro audio. Search live listings with the marketplace's own brand,
category, condition, price, year, region, shipping and seller filters, or paste links and let the
actor route them. Alongside every listing you also get the **Price Guide**: what that exact gear
model has actually **sold** for, as a median, a low and high, quartiles, a breakdown per condition,
the gap between asking and realised price, the individual recent sales, and a period by period
history.

### Why this scraper

- **Realised sale prices, not just asking prices.** An asking price tells you what a seller hopes
  for. This returns what buyers actually paid: median, low, high, 25th and 75th percentile, per
  condition, with the individual sales behind the numbers and their dates.
- **A deal rating on every live listing.** Each listing is positioned against its own model's sold
  history and labelled `below-market`, `at-market` or `above-market`, with the exact percentage
  above or below the sold median. That is the number a buyer, a dealer or a reseller acts on.
- **Over 60 fields per listing** including view and watcher counts, days on market, price drops,
  seller feedback and rating, seller location, per region shipping rates, return policy, barcode,
  videos, accepted payment methods and the canonical model id.
- **Three modes, one actor.** Keyword search across live listings, Price Guide lookup by gear model,
  and paste anything: item links, price guide links, product links, shop links, brand links,
  marketplace search links, or bare listing ids.
- **Built for recurring monitoring.** Incremental mode returns only what changed since the last run,
  so a daily watch on "1960s Stratocasters under $8,000" returns the new listings and the price
  drops instead of the same catalogue every day.
- **Priced to run at volume.** A full catalogue sweep is affordable, and the two extra-read toggles
  are opt-in so a lean run stays lean.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

#### Listing record

| Field | Example |
| --- | --- |
| `recordType` | `"listing"` |
| `listingId` | `"00000001"` |
| `title` | `"Sample Brand Model 1965 Sunburst"` |
| `make` / `model` / `year` / `finish` | `"Sample Brand"` / `"Model"` / `"1965"` / `"Sunburst"` |
| `condition` / `conditionSlug` | `"Very Good"` / `"very-good"` |
| `price` / `currency` / `priceDisplay` | `1200.00` / `"USD"` / `"$1,200"` |
| `originalPrice` / `priceDropPercent` | `1400.00` / `14` |
| `guideMedianPrice` | `1350.00` |
| `priceVsGuidePercent` | `-11.11` |
| `dealRating` | `"below-market"` |
| `rootCategory` / `categories` | `"electric-guitars"` / `["Electric Guitars / Solid Body"]` |
| `state` / `inventory` / `offersEnabled` / `offerCount` | `"live"` / `1` / `true` / `0` |
| `shopName` / `shopSlug` / `preferredSeller` | `"Sample Shop"` / `"sample-shop"` / `true` |
| `sellerFeedbackCount` / `sellerRatingPercentage` | `0` / `100.0` |
| `sellerLocation` / `sellerCountryCode` | `"Springfield, United States"` / `"US"` |
| `views` / `watchers` / `daysOnMarket` | `0` / `0` / `30` |
| `freeShipping` / `freeExpeditedShipping` / `shippingRates` | `true` / `false` / `[{"regionCode": "US", "price": 0.00}]` |
| `shippingPolicy` / `returnPolicy` | `"Shipping policy text appears here."` / `"Return policy text appears here."` |
| `photos` / `photoCount` | `["https://rvb-img.example/000000.jpg"]` / `1` |
| `publishedAt` / `createdAt` / `scrapedAt` | `"2026-01-01T00:00:00Z"` |
| `priceGuide` | the whole Price Guide block below |

#### Price Guide record

| Field | Example |
| --- | --- |
| `recordType` | `"priceGuide"` |
| `productId` / `slug` / `title` | `"000000"` / `"sample-brand-model"` / `"Sample Brand Model"` |
| `soldSalesTotal` / `soldSampleSize` | `0` / `0` |
| `soldPriceLow` / `soldPriceP25` / `soldPriceMedian` / `soldPriceP75` / `soldPriceHigh` | `900.00` / `1100.00` / `1350.00` / `1600.00` / `2200.00` |
| `soldPriceAverage` / `askPriceAverage` | `1380.00` / `1490.00` |
| `askToSoldDiscountPercent` | `7.4` |
| `firstSaleDate` / `lastSaleDate` | `"2026-01-01"` / `"2026-01-01"` |
| `byCondition` | `[{"condition": "Excellent", "salesCount": 0, "lowPrice": 1200.00, "medianPrice": 1450.00, "highPrice": 1700.00}]` |
| `recentSales` | `[{"date": "2026-01-01", "condition": "Excellent", "askPrice": 1500.00, "soldPrice": 1425.00, "currency": "USD"}]` |
| `priceHistory` | `[{"periodStart": "2026-01-01", "averageAskPrice": 1490.00, "averageSoldPrice": 1380.00}]` |
| `usedListings` / `newListings` | `0` / `0` |
| `usedLowPrice` / `newLowPrice` | `900.00` / `1899.00` |
| `productRating` / `productReviewCount` | `0` / `0` |

### How to use

Search live listings with filters:

```json
{
  "mode": "search",
  "queries": ["Fender Stratocaster"],
  "category": "electric-guitars",
  "conditions": ["excellent", "very-good"],
  "minPrice": 800,
  "maxPrice": 3000,
  "minYear": 1960,
  "maxYear": 1979,
  "includeSoldPriceGuide": true,
  "maxItems": 50
}
```

Look up what gear models actually sell for:

```json
{
  "mode": "price-guide",
  "queries": ["Moog Subsequent 37", "Shure SM57"],
  "includeSoldPriceGuide": true,
  "maxItems": 20
}
```

Paste links of any supported kind:

```json
{
  "mode": "url",
  "urls": [
    "https://reverb.com/item/00000001-sample-listing",
    "https://reverb.com/price-guide/sample-brand-model",
    "https://reverb.com/shop/sample-shop",
    "https://reverb.com/marketplace?query=Gibson%20Les%20Paul&condition=used"
  ],
  "includeSoldPriceGuide": true,
  "maxItems": 100
}
```

Watch a search daily and get only the changes:

```json
{
  "mode": "search",
  "queries": ["1960s Stratocaster"],
  "maxPrice": 8000,
  "incrementalMode": true,
  "stateKey": "vintage-strat-watch",
  "maxItems": 0
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search`, `price-guide` or `url`. |
| `queries` | array | `["Fender Stratocaster"]` | Keywords, read in search and Price Guide modes. Each is searched separately. |
| `urls` | array | | Links or listing ids, read in URL mode. Filters below are ignored in this mode. |
| `make` | string | | Brand. Applies to search and Price Guide modes. |
| `category` | string | any | One of the 14 top-level categories. Applies to search and Price Guide modes. |
| `minYear` / `maxYear` | integer | | Year window. Applies to search and Price Guide modes. |
| `conditions` | array | `[]` | One or more of `new`, `b-stock`, `used`, `mint`, `excellent`, `very-good`, `good`, `fair`, `poor`, `non-functioning`. Search mode only. |
| `minPrice` / `maxPrice` | integer | | Price window in US dollars. Search mode only. |
| `itemRegion` | string | any | Seller country. Search mode only. |
| `shipsTo` | string | anywhere | Destination the seller ships to. Search mode only. |
| `shopSlug` | string | | One seller, given as the handle in the shop address. Search mode only. |
| `handmadeOnly` | boolean | `false` | Handmade or custom built only. Search mode only. |
| `freeShippingOnly` | boolean | `false` | Only listings that ship free. Search mode only. |
| `preferredSellersOnly` | boolean | `false` | Preferred sellers only. Search mode only. |
| `sortBy` | string | `relevance` | `relevance`, `price-asc`, `price-desc` or `newest`. Search mode only. |
| `includeSoldPriceGuide` | boolean | `true` | Attach the realised sale statistics, and score each listing against them. Adds a per result surcharge. |
| `fetchDetails` | boolean | `false` | Read each listing's own item page for views, watchers, seller location, policies, barcode and videos. Adds a per result surcharge. |
| `maxItems` | integer | `20` | The run's cap. `0` for unlimited. |
| `maxPages` | integer | `0` | Pages per keyword or link, 50 results a page. `0` for no page limit. |
| `resumeFromRunId` | string | | Continue one interrupted run without returning or charging for what it already collected. |
| `incrementalMode` | boolean | `false` | Return only what changed since the last run of the same search. |
| `stateKey` | string | | Name a monitoring campaign. Derived automatically when empty. |
| `emitUnchanged` | boolean | `false` | Also return unchanged results. Returns and bills extra rows. |
| `emitExpired` | boolean | `false` | Also return results that disappeared. Returns and bills extra rows. |
| `proxy` | object | Apify Proxy | Connection settings. Leave the default selected. |
| `mcpConnectors` | array | | Optional MCP connectors to pipe results into. |
| `notionParentPageUrl` | string | | Notion page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector. |

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "recordType": "listing",
  "listingId": "00000001",
  "sku": "REF-0001",
  "slug": "sample-brand-model-1965-sunburst",
  "url": "https://reverb.com/item/00000001-sample-brand-model-1965-sunburst",
  "comparisonShoppingPageId": "000000",
  "title": "Sample Brand Model 1965 Sunburst",
  "make": "Sample Brand",
  "brandSlug": "sample-brand",
  "model": "Model",
  "year": "1965",
  "finish": "Sunburst",
  "rootCategory": "electric-guitars",
  "categories": ["Electric Guitars / Solid Body"],
  "condition": "Very Good",
  "conditionSlug": "very-good",
  "price": 1200.0,
  "currency": "USD",
  "priceDisplay": "$1,200",
  "originalPrice": 1400.0,
  "priceDropPercent": 14,
  "state": "live",
  "inventory": 1,
  "offersEnabled": true,
  "offerCount": 0,
  "isAuction": false,
  "freeShipping": true,
  "freeExpeditedShipping": false,
  "shippingRates": [{ "regionCode": "US", "price": 0.0, "currency": "USD" }],
  "shopName": "Sample Shop",
  "shopSlug": "sample-shop",
  "preferredSeller": true,
  "sellerFeedbackCount": 0,
  "sellerRatingPercentage": 100.0,
  "sellerLocation": "Springfield, United States",
  "sellerCountryCode": "US",
  "views": 0,
  "watchers": 0,
  "daysOnMarket": 30,
  "publishedAt": "2026-01-01T00:00:00Z",
  "scrapedAt": "2026-01-01T00:00:00Z",
  "guideMedianPrice": 1350.0,
  "priceVsGuidePercent": -11.11,
  "dealRating": "below-market",
  "priceGuide": {
    "soldSalesTotal": 0,
    "soldSampleSize": 0,
    "currency": "USD",
    "soldPriceLow": 900.0,
    "soldPriceP25": 1100.0,
    "soldPriceMedian": 1350.0,
    "soldPriceP75": 1600.0,
    "soldPriceHigh": 2200.0,
    "soldPriceAverage": 1380.0,
    "askPriceAverage": 1490.0,
    "askToSoldDiscountPercent": 7.4,
    "firstSaleDate": "2026-01-01",
    "lastSaleDate": "2026-01-01",
    "byCondition": [
      { "condition": "Excellent", "salesCount": 0, "lowPrice": 1200.0, "medianPrice": 1450.0, "highPrice": 1700.0 }
    ],
    "recentSales": [
      { "date": "2026-01-01", "condition": "Excellent", "askPrice": 1500.0, "soldPrice": 1425.0, "currency": "USD" }
    ],
    "priceHistory": [
      { "periodStart": "2026-01-01", "averageAskPrice": 1490.0, "averageSoldPrice": 1380.0 }
    ],
    "liveMarket": { "usedListings": 0, "newListings": 0, "usedLowPrice": 900.0, "newLowPrice": 1899.0 }
  }
}
```

### Reading the Price Guide

- `soldPriceMedian` is the middle realised price across the sample, and is the number to compare an
  asking price against. `soldPriceP25` and `soldPriceP75` bracket the normal trading range.
- `askToSoldDiscountPercent` is how far below the asking price these items actually changed hands,
  averaged per sale. A high number means sellers of this model routinely accept offers.
- `byCondition` matters more than the headline median on vintage gear, where condition can move the
  price several times over.
- `priceHistory` shows the average asking and average realised price period by period, so a model
  that is appreciating or softening is visible without any extra work.
- `soldSampleSize` is how many sales the statistics were computed over, and `soldSalesTotal` is how
  many the source holds. A small sample is reported honestly rather than hidden: when it is under
  five sales, `dealRating` is left empty instead of guessed.

### Send results into your apps (MCP connectors)

Optionally pipe results into Notion, Linear, Airtable or Apify via MCP connectors, using the
**Export to your apps (MCP connectors, optional)** section of the input. Authorize a connector under
Apify, Settings, API and Integrations, then select it here.

- `mcpConnectors` selects the connectors this run exports into.
- `notionParentPageUrl` is the Notion page under which one page per item is created. It is required
  for the Notion export and ignored by every other connector.
- `maxNotifyListings` caps how many items are written to each connector.

Each connector receives a condensed, human readable summary per item: a title plus the key fields
flattened to plain text, with nested objects collapsed to their main value and long lists trimmed.
The complete record, including the whole `priceGuide` block, always stays in the Apify dataset. The
export is a side channel: it never changes the dataset output, and a connector error is logged as a
warning while the run still succeeds.

### Notes on coverage

- A single keyword search is walked forward until the source runs out of results, the page limit is
  reached, or `maxItems` is reached. To go deeper than one search can reach, split the work with the
  brand, category, condition, price or year filters.
- The category and price filters are applied twice: once upstream, so the walk itself is narrow, and
  once against each returned listing's own category and its own US dollar price. The source
  relevance-matches nearby categories into its results and applies a price window to the seller's own
  currency, so the second pass is what makes the filter mean what the input says it means. It can
  return fewer than `maxItems` rows, which is the filter doing its job.
- A listing counts as free shipping when it quotes a zero shipping rate to any destination it ships
  to, which is what the marketplace's own free shipping filter selects.
- Price Guide statistics are computed from the sales the source publishes for that model. Models
  with no recorded sales return the live market snapshot (how many are listed used and new, and the
  lowest asking price) with the sold statistics left empty rather than filled with zeros.
- Prices are returned in US dollars, which is the currency the source reports for comparison. A sale
  recorded in another currency is excluded from the statistics rather than mixed in, and the count
  of excluded sales is reported on the record as `mixedCurrencySalesSkipped`.

### Plan requirement

An Apify account is required to run the actor. Apify Proxy is recommended; leave the default
connection selected.

# Actor input Schema

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

Choose 'search' for keyword search across live listings with filters, 'price-guide' to look up gear models and their realised sale prices (median, range, per condition, over time), or 'url' to scrape pasted links.

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

One or more keywords. In search mode each keyword returns live listings; in Price Guide mode each keyword returns matching gear models with their sold-price statistics. Examples: 'Fender Stratocaster', 'Moog Subsequent 37', 'Shure SM57'.

## `urls` (type: `array`):

Mix freely: item links (reverb.com/item/<id>), Price Guide or product links (reverb.com/price-guide/<slug> or reverb.com/p/<slug>), shop links (reverb.com/shop/<slug>), brand links (reverb.com/brand/<slug>), marketplace search links (reverb.com/marketplace?query=...), or bare listing ids. A link that is not one of these is reported and skipped rather than guessed at.

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

Only return gear from this brand, for example 'Fender', 'Gibson', 'Moog' or 'Shure'. Applies to search mode and Price Guide mode.

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

Only return gear in this top-level category. Applies to search mode and Price Guide mode. The source also relevance-matches nearby categories into its own results, so in search mode the actor additionally checks each listing's own category and drops the ones that do not belong.

## `minYear` (type: `integer`):

Only return gear made in this year or later. Applies to search mode and Price Guide mode. Useful with the latest year for vintage windows, for example 1950 to 1969.

## `maxYear` (type: `integer`):

Only return gear made in this year or earlier. Applies to search mode and Price Guide mode.

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

Only return listings in these conditions. Pick several to combine them. Search mode only. Note the source answers an unknown condition with the WHOLE catalogue rather than an error, so a value it does not recognise stops the run instead of quietly returning everything.

## `minPrice` (type: `integer`):

Only return listings priced at or above this amount, in US dollars. Search mode only. The window is also re-checked against each listing's reported US dollar price, because the source applies it to the seller's own currency.

## `maxPrice` (type: `integer`):

Only return listings priced at or below this amount, in US dollars. Search mode only. The window is also re-checked against each listing's reported US dollar price, because the source applies it to the seller's own currency.

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

Only return listings whose seller is in this country. Search mode only.

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

Only return listings the seller will ship to this country. Search mode only.

## `shopSlug` (type: `string`):

Only return listings from one shop, given as the shop handle in its address, for example 'guitar-sauce-italy' from reverb.com/shop/guitar-sauce-italy. Search mode only. To sweep a shop without setting a keyword, paste its shop link in URL mode instead.

## `handmadeOnly` (type: `boolean`):

Only return gear the seller has marked as handmade or custom built. Search mode only.

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

Only return listings that ship free. Search mode only. A listing counts as free shipping when it quotes a zero rate to any destination it ships to.

## `preferredSellersOnly` (type: `boolean`):

Only return listings from sellers the marketplace has marked as preferred. Search mode only.

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

Ordering asked of the source for a keyword search. Search mode only. Only orderings the source actually honours are offered here.

## `includeSoldPriceGuide` (type: `boolean`):

Attach what this gear has actually SOLD for: median, low, high, quartiles, a breakdown per condition, the average gap between asking and realised price, the recent individual sales, and a period-by-period history. In search and URL modes it also scores each live listing against that history (below market, at market, above market). Turn off for the cheapest run: Price Guide records then keep only the live-market snapshot (how many are listed used and new, and the lowest asking price).

## `fetchDetails` (type: `boolean`):

Adds view and watcher counts, seller location, shipping and return policies, barcode, videos and accepted payment methods to every listing. Off by default because the result page already carries title, brand, model, year, finish, condition, price, seller and photos. Turning on the Price Guide above reads the item page too, so switching this on as well costs nothing extra.

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

Maximum number of results returned across the whole run. This is the run's cap. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum result pages walked per keyword or link, at 50 results a page. 0 means no page limit: the run then stops only at Max results, or when the source runs out of results.

## `resumeFromRunId` (type: `string`):

Paste a previous run id or dataset id to continue a large crawl without returning, or charging for, results already collected there. Use this after an interrupted run. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns everything matching as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED results, which is how you catch a price drop or a fresh listing of a model you watch. State is kept separately for each mode, keyword set and filter setup, so two different searches never mix.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key from the mode, keywords, links and filters.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return results that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return results that were present in a previous run but are no longer found, marked EXPIRED, which is how a listing selling or being withdrawn shows up. Only produced once a run has fully scanned the tracked search, never when Max results capped it or Resume was used. This returns, and bills, extra rows.

## `proxy` (type: `object`):

Apify Proxy is recommended. Leave the default selected unless a run reports that requests were refused.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API and Integrations, then select it here. Notion gets a rich page per item; other connectors get a best-effort write or digest. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "Fender Stratocaster"
  ],
  "urls": [
    "https://reverb.com/marketplace?query=Gibson%20Les%20Paul&condition=used",
    "https://reverb.com/price-guide/fender-american-professional-ii-stratocaster"
  ],
  "category": "",
  "conditions": [],
  "itemRegion": "",
  "shipsTo": "",
  "handmadeOnly": false,
  "freeShippingOnly": false,
  "preferredSellersOnly": false,
  "sortBy": "relevance",
  "includeSoldPriceGuide": true,
  "fetchDetails": false,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "Fender Stratocaster"
    ],
    "urls": [
        "https://reverb.com/marketplace?query=Gibson%20Les%20Paul&condition=used",
        "https://reverb.com/price-guide/fender-american-professional-ii-stratocaster"
    ],
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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": "search",
    "queries": ["Fender Stratocaster"],
    "urls": [
        "https://reverb.com/marketplace?query=Gibson%20Les%20Paul&condition=used",
        "https://reverb.com/price-guide/fender-american-professional-ii-stratocaster",
    ],
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "mode": "search",
  "queries": [
    "Fender Stratocaster"
  ],
  "urls": [
    "https://reverb.com/marketplace?query=Gibson%20Les%20Paul&condition=used",
    "https://reverb.com/price-guide/fender-american-professional-ii-stratocaster"
  ],
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/reverb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/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/tNcxg4WGUqh2dgzYs/builds/uU95hIfH1ppLRjcpJ/openapi.json