# Reverb Scraper \[$0.45💰] | Music Gear Listings | Price Data (`ahmed_jasarevic/reverb-scraper`) Actor

Scrape music-gear listings from Reverb.com: title, price, shipping, make, model and year across six shipping regions. Built for used-gear price monitoring, guitar price guides and music-gear market research. Structured JSON via the public Reverb API on Apify.

- **URL**: https://apify.com/ahmed_jasarevic/reverb-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.43 / 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 — Music Gear Listings, Prices And Shipping Data From Reverb.com

The Reverb Scraper returns **43 fields per listing** — price, shipping by region, make/model/year/finish, condition, seller and photos — as one flat row per live listing, fetched from Reverb's public JSON API instead of scraped HTML. Its main job is **used gear price monitoring**: track live asking prices, price drops and new listings across the world's largest marketplace for guitars, pedals, synths, drums and pro audio.

### Main Use Cases: Guitar Flipping, Price Monitoring And Music-Gear Market Research

- **Used gear price monitoring / Reverb price tracker** — schedule recurring runs, diff rows on `id` + `priceAmount` + `scrapedAt`; catch price drops, new stock and delistings. `offersEnabled` supports make-an-offer tracking.
- **Guitar price guide lookups** — answer "how much is my guitar worth" with live asking prices for model-level queries (e.g. `fender stratocaster used price`), split by `condition`.
- **Vintage guitar valuation and vintage synth prices** — `make`, `model`, `year`, `finish`, `condition` and the full category path (e.g. `Electric Guitars / Solid Body`) on every row.
- **Guitar flipping and pedal flipping profit** — sort `price|asc`, filter `make`/`category`, surface underpriced listings early; detail fetches add `views`, `watches`, `offerCount` so you can read demand, not just price.
- **Music gear price comparison** — export flat rows and compare Reverb asking prices against eBay or Guitar Center data for the same make/model/year.
- **Reverb price alerts and music gear market research** — daily runs plus webhooks for deal alerts; bulk rows for the used musical equipment market and the vintage instrument market.

### How The Reverb Scraper Works

Two modes can run together. **Search mode** pages `searchQueries` against Reverb's public search endpoint (50 listings/page, up to `maxPagesPerQuery` pages each); **detail mode** fetches each ID in `listingIds` against the detail endpoint, which adds fields the search payload lacks (seller location, view/watch/offer counts). A unit-tested mapper (`src/mapper.ts`, vitest) flattens each payload into one dataset row. Runs on `CheerioCrawler` at **256 MB with no browser**, enforces `maxItems`/`maxRequestsPerCrawl`, and stops at 10 rows for free accounts.

### Input Parameters: Search Queries, Filters, Shipping Region And Run Caps

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchQueries` | array\<string> | No (prefilled) | `["fender stratocaster"]` | Search terms; each query is paged independently at 50 listings/page |
| `listingIds` | array\<string> | No | `[]` | Numeric listing IDs from `reverb.com/item/…` URLs, fetched in full detail (tracking specific listings over time) |
| `make` | string | No | `""` | Brand filter for every search (e.g. `Fender`); passed through as `&make=` |
| `category` | string | No | `""` | Category slug for every search (e.g. `electric-guitars`); passed through as `&category=` |
| `sort` | string | No | `""` | Reverb sort expression passed through as `&sort=`, e.g. `price\|asc` or `price\|desc` |
| `maxPagesPerQuery` | integer | No | `2` | Max result pages per search query (min 1, max 50) |
| `maxItems` | integer | No | `100` | Hard cap on total rows (min 1; free users are capped at 10 items) |
| `shippingRegion` | string | No | `US` | Region for shipping costs via the `X-Shipping-Region` header: `US`, `CA`, `GB`, `EUR_EU`, `EUR_NON_EU`, `XX` (everywhere else) |
| `maxRequestsPerCrawl` | integer | No | `300` | Safety ceiling on API requests, retries included (min 1, max 1000) |
| `proxy` | object | No | `{"useApifyProxy": false}` | Standard Apify proxy picker; off by default (the JSON API answers without it) |

Runs are driven by `searchQueries` and/or `listingIds`; no field is required in the schema.

### Output Fields: 43 Flat Listing Fields With Overview And Details Views

One flat row per listing; all 43 fields are stored in the dataset. The two Console views (in [`.actor/dataset_schema.json`](.actor/dataset_schema.json)) only change table rendering.

- **Listing identity (3):** `id` (listing ID), `title`, `url` (listing URL on reverb.com).
- **Price (4):** `priceAmount` (numeric, null if unknown), `priceAmountCents`, `priceCurrency` (ISO 4217, e.g. `USD`), `priceDisplay` (formatted, e.g. `$4,150`).
- **Gear specs (4):** `make`, `model`, `year` (null/empty for modern or unknown gear), `finish` (e.g. `Olympic White`).
- **Condition (2):** `condition` (display grade — `Brand New`, `Excellent`, `Very Good`, `Good`, `Fair`, …), `conditionSlug` (e.g. `very-good`).
- **Seller (4):** `sellerName` (shop name), `sellerSlug` (shop URL slug; null on detail fetches), `sellerPreferred`, `sellerLocation` (detail endpoint only; null on search rows).
- **Category (2):** `category` (primary path, e.g. `Electric Guitars / Solid Body`), `categories` (all paths).
- **Photos (2):** `photos` (search rows carry the primary photo, `listingIds` detail fetches the full set), `photoCount`.
- **Inventory & offers (3):** `inventory` (units), `hasInventory`, `offersEnabled` (buyers can send offers).
- **Shipping (7):** `shippingRegion` (region of the resolved rate; null when no rates, e.g. local pickup), `shippingCost` (0 = free, null unknown), `shippingCurrency`, `shippingDisplay`, `shippingRates` (all per-region rates: `region`, `cost`, `currency`, `display`, `carrierCalculated`), `freeExpeditedShipping`, `localPickupOnly` (detail endpoint only).
- **Monitoring & state (9):** `state` (e.g. `live`), `auction`, `listingCurrency`, `sku`, `createdAt`, `publishedAt`, `views`, `watches`, `offerCount` (last three from detail fetches; null on search rows).
- **Provenance (3):** `source` (endpoint that produced the row, e.g. `search`), `query` (search query; null for detail fetches), `scrapedAt`.

**Console views:** `overview` — 9 quick columns (`id`, `title`, `priceDisplay`, `condition`, `sellerName`, `category`, `offersEnabled`, `shippingDisplay`, `url`); `details` — the other 33 columns: identity, specs, seller, category, inventory, shipping, photos, state, timestamps, provenance.

### Example Input And Output

Example input — two filtered searches, 100-row cap, US shipping:

```json
{
  "searchQueries": ["fender stratocaster", "fender telecaster"],
  "make": "Fender",
  "category": "electric-guitars",
  "sort": "price|asc",
  "maxPagesPerQuery": 2,
  "maxItems": 100,
  "shippingRegion": "US",
  "maxRequestsPerCrawl": 300
}
```

Example output — one search-mode dataset row (key fields shown; the full row carries all 43 fields listed above):

```json
{
  "id": 95035100,
  "title": "1974 Fender Stratocaster Olympic White",
  "url": "https://reverb.com/item/95035100",
  "priceAmount": 4150.0,
  "priceCurrency": "USD",
  "priceDisplay": "$4,150",
  "make": "Fender",
  "model": "Stratocaster",
  "year": 1974,
  "finish": "Olympic White",
  "condition": "Very Good",
  "sellerName": "Guitars for Miles",
  "category": "Electric Guitars / Solid Body",
  "photos": ["https://rvb-img.reverb.com/i/....jpg"],
  "offersEnabled": true,
  "shippingRegion": "US_CON",
  "shippingCost": 132.76,
  "shippingCurrency": "USD",
  "shippingDisplay": "$132.76",
  "shippingRates": [{"region": "US_CON", "cost": 132.76, "currency": "USD", "display": "$132.76", "carrierCalculated": false}],
  "source": "search",
  "query": "fender stratocaster",
  "scrapedAt": "2026-10-07T11:00:00.000Z"
}
```

`views`, `watches`, `offerCount`, `sellerLocation` and `localPickupOnly` are null on search rows and populated by `listingIds` detail fetches; `query` is null there. Local dev: `apify run -i '{"searchQueries":["moog sub 37"]}'`, `npx vitest run` (mapper tests), `apify validate-schema`.

### What Is The Reverb API And How Does This Scraper Use It?

The Actor does **not** scrape HTML. It calls Reverb's **public JSON API**:

| Purpose | Endpoint | Notes |
| --- | --- | --- |
| Marketplace search | `https://api.reverb.com/api/listings?query=…&page=…&per_page=50` | Optional passthrough params: `make=`, `category=`, `sort=` (e.g. `price\|asc`). `per_page` is capped at 50 by the API |
| Listing detail | `https://api.reverb.com/api/listings/{id}` | Extra fields: seller location, view/watch counts, offer count |

Both endpoints require exactly one header besides `Accept`:

```
Accept-Version: 3.0
```

The API self-documents this — older versions reply *"Please use 'Accept-Version: 3.0'"* — and there is **no API key, no cookie**, with CORS open (`access-control-allow-origin: *`). Official docs: [reverb.com/page/api](https://reverb.com/page/api).

**Why this strategy (reverse-engineering notes):**

1. **Embedded JSON in HTML — not applicable.** A plain `curl https://reverb.com/` returns `403` with `cf-mitigated: challenge` (Cloudflare) — no HTML to grep for `__NEXT_DATA__`/`ld+json`.
2. **Third-party search backend — not needed.** Reverb runs its own search API.
3. **Internal JSON API — found and used.** `api.reverb.com/api/listings` is the exact XHR endpoint the Reverb frontend calls; it answers `200` with `application/hal+json` from any datacenter IP, no challenge — the HTML site is walled, the JSON API is open.
4. **Playwright/browser — deliberately avoided.** Nothing in the payload needs JS rendering, so the Actor runs on `CheerioCrawler` at **256 MB** (max 512) — no browser, no paid anti-bot service.

**Cost profile:** no browser, no proxy by default, no paid anti-bot API — one unit of work is one lightweight JSON GET (~1 KB per 50 listings), so runs cost a few cents in compute. Enable the standard Apify proxy only if Reverb rate-limits you.

### Reverb Price Tracker: Monitor Live Listings, Shipping Costs And Price Drops

**Monitoring workflow.** Run the same queries on a schedule and join new rows to the previous run on `id`: lower `priceAmount` = price drop, new `id` = new listing, missing `id` = sold or ended. Detail mode (`listingIds`) watches specific listings over time — the only mode returning `views`, `watches`, `offerCount` and `sellerLocation`. The Actor returns **live listings, not sold history**; Reverb's own Price Guide covers sold-based estimates.

**Shipping-region quirk.** The `X-Shipping-Region` header does two things — it deterministically resolves shipping rates *and* it shapes the visible result set like the shipping-region picker on Reverb.com. Results vary per region: a test query returned **30 items for `US`, 18 for `GB`, 16 for `CA`**. It is always sent (otherwise costs would follow the exit IP's geolocation). For maximum coverage, run the same query for several values (`US`, `CA`, `GB`, `EUR_EU`, `EUR_NON_EU`, `XX`) — Reverb is US-based (footer defaults to Continental U.S. / USD) but runs localized UK/EU storefronts and ships internationally.

**Limits & safety.** `maxRequestsPerCrawl` (default 300, max 1000) hard-caps API calls, retries included; `maxConcurrency: 3`, `maxRequestRetries: 3`, per-request timeouts set; HTTP 429 backs off 5 s before Crawlee retries. The crawl stops at `maxItems` (default 100); `maxPagesPerQuery` (default 2, max 50) bounds each search.

**Free vs. paid.** Free users get a preview capped at **10 listings** per run (`APIFY_USER_IS_PAYING !== '1'`); paying users get the full run up to `maxItems`.

### Integrations & Automation

- **Apify API** — run the Actor and read the dataset in one call:

  ```bash
  curl -X POST \
    "https://api.apify.com/v2/acts/ahmed_jasarevic~reverb-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"searchQueries":["fender stratocaster"],"maxItems":50}'
  ```

- **Webhooks** — push each new dataset into your pipeline (price-drop alerts, inventory syncs) on `actor.run.succeeded`.

- **Zapier / Make** — the built-in Apify integration triggers on new rows or starts runs (e.g. a daily scan appending price changes to a Google Sheet).

- **Schedules** — **daily** for reverb price alert / deal-finder flows, **weekly** for guitar price guide and market-research sweeps (e.g. cron `0 8 * * *` = 08:00 UTC daily).

- **CLI** — `apify push` to deploy, then `apify call reverb-scraper --input '{"searchQueries":["gibson les paul"],"maxItems":20}'`.

### Related Actors

- [Reverb Music Gear Marketplace Scraper](https://apify.com/crawlerbros/reverb-scraper) — same-site Store competitor for the same music-gear query set.
- [Reverb Price Guide Used Gear Scraper](https://apify.com/jungle_synthesizer/reverb-price-guide-used-gear-scraper) — price-guide (used-gear pricing) angle, complementary to live listings.
- [Reverb Musical Instruments Scraper](https://apify.com/parseforge/reverb-com-scraper) — flat-row Reverb listings for music-gear market-research users.
- [Reverb Scraper — Musical Instrument Listings & Prices API](https://apify.com/nexgendata/reverb-musical-instrument-scraper) — monitoring-oriented competitor (daily price/listing watch framing).
- [Reverb Scraper — Sold Listings & Price Guide](https://apify.com/devilscrapes/reverb-sold-listings) — "used guitar price data": sold price-guide ranges, the sold-history complement to live asking prices.

### FAQ

#### Is there an official Reverb API?

Yes. Reverb exposes a public JSON API at `api.reverb.com` (docs at [reverb.com/page/api](https://reverb.com/page/api)) with a search endpoint (`/api/listings`) and a detail endpoint (`/api/listings/{id}`). No API key and no cookie: both work with one extra header, `Accept-Version: 3.0`, and CORS is open (`access-control-allow-origin: *`). This Actor calls exactly those endpoints.

#### Why use this actor instead of calling the official API myself?

Honest answer: this Actor *uses* the same public `api.reverb.com` API — it does not unlock data you cannot fetch yourself. What it adds is the plumbing: automatic paging (50 listings/page) with `maxPagesPerQuery`/`maxItems`/`maxRequestsPerCrawl` caps, the `X-Shipping-Region` logic (deterministic rates), a unit-tested mapper flattening Reverb's nested JSON into 43 stable fields, 429 backoff and retries, free-vs-paid gating, Overview/Details views, and one-click Apify schedules, webhooks, API and Zapier/Make.

#### Does this scraper return sold prices or price history?

No. Rows are **live listings and their asking prices** (`state: live`, with `createdAt`, `publishedAt`, `scrapedAt`) — not sold comps. For sold-based ranges, Reverb's own Price Guide is the reference; this Actor answers the complementary question: what is the market asking right now, by condition and by region.

#### How much is my guitar worth — can this actor price my used guitar?

For live asking prices, yes. Run a model query such as `fender stratocaster used price` (optionally `sort: price|asc`) and read `priceAmount`/`priceDisplay` across rows grouped by `condition` and `year`. `make`, `model`, `year`, `finish` narrow rows to the exact variant — live rows, not a static guide.

#### What's the difference between Reverb and eBay for selling used gear?

It is a real buyer/seller question — comparison pages (Treblemakers' Reverb vs eBay for used guitars) and TheGearPage threads debate it. This Actor reads **Reverb only**, so the data-driven way to answer it: pull Reverb rows here and join on `make`/`model`/`year`/`condition` against rows from an eBay scraper — comparing asking prices, `shippingRates` and condition mixes. The same join works for Reverb vs Guitar Center.

#### Can I get shipping cost to my country from Reverb listings?

Yes. Set `shippingRegion` (`US`, `CA`, `GB`, `EUR_EU`, `EUR_NON_EU`, `XX`): each row returns `shippingCost`, `shippingCurrency`, `shippingDisplay` for that region plus `shippingRates` — every per-region rate the seller quotes (`carrierCalculated` included), so one row can answer several countries. `freeExpeditedShipping` and `localPickupOnly` cover no-ship cases.

#### Is scraping reverb.com blocked by Cloudflare?

The HTML site is: plain `curl https://reverb.com/` returns `403` with `cf-mitigated: challenge`, leaving no `__NEXT_DATA__`/`ld+json` to scrape. The JSON API is not: `api.reverb.com/api/listings` answers `200` with `application/hal+json` from any datacenter IP. That gap is the Actor's bypass.

#### What are the alternatives to this actor?

eBay and Guitar Center are the standard marketplace comparisons for used gear (see above). On the Apify Store, see Related Actors above for five verified alternatives with relevance notes.

### SEO Keywords

reverb scraper, reverb api, reverb price tracker, reverb price api, reverb listings data, used gear price monitoring, guitar price guide, how much is my guitar worth, vintage guitar valuation, guitar flipping, pedal flipping profit, music gear price comparison, music gear market research, music gear marketplace data, used guitar price data, reverb price alert, reverb vs ebay, reverb vs guitar center, reverb alternatives, reverb shipping rates by region, fender stratocaster used price, vintage synth prices, used musical equipment market, vintage instrument market

### For AI Agents & LLM Apps

**Purpose:** fetch structured Reverb.com music-gear listing data (live asking prices, shipping, specs, seller) as flat JSON rows — search mode or listing-ID detail mode, no API key.

Minimal working input:

```json
{"searchQueries": ["fender stratocaster"]}
```

Detail-mode variant (unlocks the detail-only fields):

```json
{"listingIds": ["95035100"]}
```

Output fields (43): `id`, `title`, `url`, `priceAmount`, `priceAmountCents`, `priceCurrency`, `priceDisplay`, `make`, `model`, `year`, `finish`, `condition`, `conditionSlug`, `sellerName`, `sellerSlug`, `sellerPreferred`, `sellerLocation`, `category`, `categories`, `photos`, `photoCount`, `inventory`, `hasInventory`, `offersEnabled`, `shippingRegion`, `shippingCost`, `shippingCurrency`, `shippingDisplay`, `shippingRates`, `freeExpeditedShipping`, `localPickupOnly`, `state`, `auction`, `listingCurrency`, `sku`, `createdAt`, `publishedAt`, `views`, `watches`, `offerCount`, `source`, `query`, `scrapedAt`.

**Behaviors an agent should know:**

- `shippingRegion` (default `US`) accepts `US`, `CA`, `GB`, `EUR_EU`, `EUR_NON_EU`, `XX`; the header is always sent — it resolves `shippingCost`/`shippingRates` deterministically and reshapes the result set (test: 30 `US`, 18 `GB`, 16 `CA` rows).
- Search mode pages `/api/listings` at 50 items/page (`maxPagesPerQuery`, default 2, max 50). Detail mode (`listingIds`) fetches `/api/listings/{id}` and is the only source of `sellerLocation`, `views`, `watches`, `offerCount`, `localPickupOnly` and the full photo set; `query` and `sellerSlug` are null on detail fetches.
- Free accounts (`APIFY_USER_IS_PAYING !== '1'`) are capped at 10 listings per run; paying accounts run up to `maxItems` (default 100).
- `maxRequestsPerCrawl` (default 300, max 1000) hard-caps API requests including retries; the crawl stops at `maxItems`; HTTP 429 → 5 s backoff; `maxConcurrency` 3, `maxRequestRetries` 3.
- Optional passthrough filters: `make`, `category`, `sort` (e.g. `price|asc`). `shippingCost` `0` means free shipping; `null` means unknown (e.g. local pickup).
- No API key or cookie — the Actor sends `Accept-Version: 3.0`. Proxy off by default (unnecessary for the JSON API); memory 256 MB (max 512), no browser.

### Legal & Compliance Disclaimer

- This is an independent tool. It is not affiliated with, endorsed by, sponsored by or connected to Reverb or reverb.com.
- The Actor accesses Reverb's **public `api.reverb.com` JSON endpoints** with the documented `Accept-Version: 3.0` header — no API key, no login, no cookie, no CAPTCHA or access-control bypass. It does not scrape reverb.com HTML pages.
- The output is public marketplace data (listings, prices, shipping quotes, seller shop names). You are responsible for your own compliance with Reverb's Terms of Service and applicable data-protection and consumer-protection law.

# Actor input Schema

## `searchQueries` (type: `array`):

Search terms to run against the Reverb marketplace (e.g. "fender stratocaster", "moog sub 37"). Each query is fetched page by page from the public Reverb API.

## `listingIds` (type: `array`):

Optional Reverb listing IDs (the number in reverb.com/item/… URLs) to fetch in full detail, e.g. for tracking specific listings over time.

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

Optional brand/make filter applied to every search (e.g. "Fender", "Gibson"). Passed straight to the Reverb API as \&make=.

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

Optional category slug filter applied to every search (e.g. "electric-guitars", "pedals-and-effects"). Passed straight to the Reverb API as \&category=.

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

Optional Reverb sort expression, e.g. "price|asc" or "price|desc". Passed straight to the Reverb API as \&sort=.

## `maxPagesPerQuery` (type: `integer`):

Maximum number of result pages to fetch per search query (50 listings per page).

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

Hard cap on total listings returned by the run (paid users only; free users are capped at 10 items).

## `shippingRegion` (type: `string`):

Region used to resolve shipping costs (X-Shipping-Region header). Common values: US, CA, GB, EUR_EU, EUR_NON_EU, XX (everywhere else).

## `maxRequestsPerCrawl` (type: `integer`):

Safety ceiling on the number of API requests for the whole run.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "fender stratocaster"
  ],
  "listingIds": [],
  "maxPagesPerQuery": 2,
  "maxItems": 100,
  "shippingRegion": "US",
  "maxRequestsPerCrawl": 300,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "fender stratocaster"
    ],
    "listingIds": [],
    "make": "",
    "category": "",
    "sort": "",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "searchQueries": ["fender stratocaster"],
    "listingIds": [],
    "make": "",
    "category": "",
    "sort": "",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "searchQueries": [
    "fender stratocaster"
  ],
  "listingIds": [],
  "make": "",
  "category": "",
  "sort": "",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/reverb-scraper --silent --output-dataset

```

## MCP server setup

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