# Reverb Scraper (`solidcode/reverb-scraper`) Actor

\[💰 $5.00 / 1K] Extract new & used musical instrument listings from Reverb.com — guitars, amps, pedals, synths, drums, and pro audio gear. Get title, brand, model, year, price, condition, shipping, seller, images, and specs. Search by keyword or paste Reverb URLs.

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

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

Pull new and used musical-instrument listings from Reverb.com at scale — guitars, amps, effects pedals, synths, drums, pro audio, and DJ gear — each returned as a clean, structured row with brand, model, year, finish, price, condition, seller shop, and full photo gallery. Search by keyword, narrow by category and condition, or paste any Reverb URL. Built for gear resellers, vintage-guitar dealers, and marketplace analysts who need fresh, structured Reverb pricing data without copying listings by hand.

### Why This Scraper?

- **16 gear categories in one dropdown** — target Electric, Acoustic, and Bass Guitars, Amps, Effects & Pedals, Keyboards & Synths, Drums & Percussion, Pro Audio, DJ & Lighting Gear, and 7 more — or search the entire marketplace at once.
- **10 condition grades, filtered precisely** — from Mint and Excellent down through Good, Fair, Poor, Non-Functioning, and B-Stock, so you can isolate players-grade bargains or collector-clean pieces on demand.
- **Prices in 12 currencies** — return every listing in USD, EUR, GBP, JPY, CAD, AUD, and 6 more; the same currency also anchors your minimum/maximum price filter so bounds and results always match.
- **Up to 25 images per listing** — full photo galleries, not just the thumbnail, for condition assessment, catalog building, and visual archiving.
- **Clean, flat records with no marketplace noise** — a single `brand`, a single `images` array, plain-text descriptions (HTML stripped), and human-readable category names instead of internal codes.
- **Ship-to targeting across 10 buyer countries** — return only listings that actually ship to the US, UK, Canada, Germany, Japan, and 5 more, so you never surface gear you can't buy.
- **Four sort orders built for price discovery** — Best Match, Price Low-to-High, Price High-to-Low, and Newest Listings, ideal for catching underpriced gear or fresh drops the moment they post.
- **Seller, offer, and stock signals on every row** — shop name, seller location, live inventory count, whether the seller accepts offers, and a local-pickup-only flag.
- **Paste any Reverb URL and keep its filters** — drop a marketplace search, category, or individual listing URL and the scraper reproduces that page's exact filters — or skip URLs entirely and just type search terms.

### Use Cases

**Reseller & Pricing Intelligence**
- Track live asking prices for a specific model across every condition grade to price your own inventory competitively
- Surface underpriced listings by sorting a category Price Low-to-High
- Gauge how many of a given guitar or pedal are on the market at once to read supply and demand

**Vintage & Collectible Sourcing**
- Hunt specific years and finishes of vintage guitars, amps, and synths
- Filter to Mint and Excellent for collector-grade pieces only
- Build brand + model watchlists across the whole marketplace, not just one page

**Market Research & Analytics**
- Analyze price distributions by category, condition, and currency
- Measure brand presence and category supply, then re-run to track shifts over time
- Compare regional availability using the ship-to country filter

**Inventory & Catalog Building**
- Populate a store catalog with titles, brands, models, finishes, and photo galleries
- Enrich product databases with structured, deduplicated gear records
- Pull up to 25 images per listing for condition documentation

**Lead Generation**
- Identify active seller shops and their locations within a category
- Build lists of dealers carrying specific brands
- Find sellers who accept offers for negotiation outreach

### Getting Started

#### Simple keyword search

```json
{
  "searchTerms": ["gibson les paul"],
  "maxResults": 50
}
````

#### Browse a whole category — no keyword needed

```json
{
  "category": "electric-guitars",
  "condition": "excellent",
  "sortBy": "price-asc",
  "maxResults": 100
}
```

#### Filtered category search

```json
{
  "searchTerms": ["fender stratocaster"],
  "category": "electric-guitars",
  "condition": "excellent",
  "minPrice": 500,
  "maxPrice": 1500,
  "shipsTo": "US",
  "sortBy": "price-asc",
  "currency": "USD"
}
```

#### From a Reverb URL

```json
{
  "startUrls": ["https://reverb.com/marketplace/effects-and-pedals?query=boss"],
  "currency": "GBP",
  "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `["https://reverb.com/marketplace?query=fender%20stratocaster"]` | One or more Reverb URLs — marketplace searches, category pages, or individual listing pages. The type of each URL is detected automatically and its on-page filters (brand, price, sort, and so on) are reused. You can mix types in one run. |
| `searchTerms` | array | `["gibson les paul"]` | Keyword searches such as `gibson les paul` or `boss ds-1`. Each term runs as its own Reverb search — no URL building needed. Use either or both of these fields. |

#### Search Filters

These refine your **Search Terms** — or, when you enter no search term and no URL, they browse the marketplace on their own (for example, pick just a category to pull an entire category). When you paste a URL, every filter comes from the URL itself.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `all` | Limit results to one of 16 gear categories: All Categories, Electric Guitars, Acoustic Guitars, Bass Guitars, Amps, Effects & Pedals, Keyboards & Synths, Drums & Percussion, Pro Audio, DJ & Lighting Gear, Home Audio, Folk Instruments, Band & Orchestra, Software, Recorded Music, Accessories, Parts. Works with a search term, or on its own to browse the whole category. |
| `condition` | string | `all` | Return only one condition: Any Condition, Used (any pre-owned), New, Mint, Excellent, Very Good, Good, Fair, Poor, Non-Functioning, or B-Stock. |
| `minPrice` | integer | — | Only listings priced at or above this amount, in the selected currency. Leave empty for no minimum. |
| `maxPrice` | integer | — | Only listings priced at or below this amount, in the selected currency. Leave empty for no maximum. |
| `shipsTo` | string | `any` | Only listings that can ship to a chosen country: Anywhere, United States, United Kingdom, Canada, Australia, Germany, France, Italy, Spain, Netherlands, or Japan. |
| `sortBy` | string | `relevance` | Result ordering: Best Match, Price: Low to High, Price: High to Low, or Newest Listings. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | string | `USD` | Currency for output prices and the price filters above: US Dollar, Euro, British Pound, Canadian Dollar, Australian Dollar, Japanese Yen, New Zealand Dollar, Swiss Franc, Swedish Krona, Norwegian Krone, Danish Krone, or Mexican Peso. |
| `maxResults` | integer | `100` | Maximum listings to return across all URLs and searches. Set to `0` for unlimited. Start with 10–50 to test, then increase. |

### Output

Each listing is returned as one flat record. Example:

```json
{
  "id": "84521093",
  "title": "Gibson Les Paul Standard '50s 2021 Heritage Cherry Sunburst",
  "url": "https://reverb.com/item/84521093-gibson-les-paul-standard-50s-2021-heritage-cherry-sunburst",
  "slug": "gibson-les-paul-standard-50s-2021-heritage-cherry-sunburst",
  "brand": "Gibson",
  "model": "Les Paul Standard '50s",
  "year": "2021",
  "finish": "Heritage Cherry Sunburst",
  "category": "electric-guitars",
  "condition": "Excellent",
  "description": "Beautiful 2021 Gibson Les Paul Standard '50s in Heritage Cherry Sunburst. Includes the original hardshell case and all case candy. Light play wear, plays and sounds fantastic.",
  "price": 1899.0,
  "currency": "USD",
  "priceDisplay": "$1,899",
  "buyerPrice": 1899.0,
  "offersEnabled": true,
  "isAuction": false,
  "listingType": "MAKE_AN_OFFER",
  "state": "live",
  "sold": false,
  "localPickupOnly": false,
  "inventory": 1,
  "hasInventory": true,
  "shopName": "Chicago Music Exchange",
  "sellerLocation": "Chicago, IL, United States",
  "image": "https://rvb-img.reverb.com/image/upload/.../photo-1.jpg",
  "images": [
    "https://rvb-img.reverb.com/image/upload/.../photo-1.jpg",
    "https://rvb-img.reverb.com/image/upload/.../photo-2.jpg"
  ],
  "createdAt": "2024-11-03T14:22:08Z",
  "publishedAt": "2024-11-03T14:25:41Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Reverb listing identifier |
| `title` | string | Full listing title |
| `url` | string | Web address of the listing |
| `slug` | string | URL slug of the listing |
| `brand` | string | Make / manufacturer |
| `model` | string | Model name |
| `year` | string | Year or era (when stated) |
| `finish` | string | Colour or finish (when stated) |
| `category` | string | Top-level gear category |
| `condition` | string | Condition display name (e.g. Excellent) |
| `description` | string | Listing description as plain text |

#### Pricing & Offers

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Listing price as a number |
| `currency` | string | Currency code of the price |
| `priceDisplay` | string | Formatted price string (e.g. `$1,899`) |
| `buyerPrice` | number | Buyer-facing price |
| `offersEnabled` | boolean | Whether the seller accepts offers |
| `isAuction` | boolean | Whether the listing is an auction |
| `listingType` | string | Listing type (e.g. `BUY_IT_NOW`, `MAKE_AN_OFFER`) |

#### Availability & Seller

| Field | Type | Description |
|-------|------|-------------|
| `state` | string | Listing state (e.g. live, sold, ended) |
| `sold` | boolean | Whether the listing has sold |
| `inventory` | number | Quantity available |
| `hasInventory` | boolean | Whether stock is available |
| `localPickupOnly` | boolean | Whether the item is local pickup only |
| `shopName` | string | Seller shop name |
| `sellerLocation` | string | Seller region / country |

#### Media & Timestamps

| Field | Type | Description |
|-------|------|-------------|
| `image` | string | Primary image URL |
| `images` | array | All image URLs (up to 25 per listing) |
| `createdAt` | string | When the listing was created (ISO-8601 UTC) |
| `publishedAt` | string | When the listing was published (ISO-8601 UTC) |

### Tips for Best Results

- Start with a `maxResults` of 10–50 to preview the record shape and confirm your filters before launching a large run.
- **Find underpriced gear:** point a category URL (or a category search) at `sortBy` = Price: Low to High — the cheapest examples of a model float straight to the top, ideal for flip candidates the moment they list.
- Ask for exactly the number of listings you need — `maxResults` returns that many precisely (request 300 and you get 300), so you only pay for what you asked for.
- A single search returns up to roughly 25,000 listings; to go deeper on a huge category, split the run by category or by price band (e.g. several `minPrice`/`maxPrice` windows).
- Match `currency` to your market — it localizes both the output prices and your min/max price bounds, so filters behave exactly as you'd expect.
- Combine a keyword with a category to cut noise — e.g. `stratocaster` inside Electric Guitars avoids unrelated straps, cases, and parts.
- Reuse a filter set you already built on Reverb by pasting its URL into `startUrls` — the on-page category, price, and sort settings carry straight over.

### Pricing

**From $5.00 per 1,000 results** — flat, predictable pay-per-result pricing with no surprises. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is one listing record pushed to your dataset. Apify platform fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications when a run finishes
- **Webhooks** — Trigger your own systems on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available listing data from Reverb.com for legitimate purposes such as market research, pricing analysis, and catalog building. Use it responsibly: respect Reverb's Terms of Service, avoid excessive request volumes, and comply with all applicable laws and regulations — including data-protection rules — when handling any collected data. You are responsible for how you use the data you extract.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Reverb.com URLs. Works with marketplace search result pages, category pages, and individual listing pages — the scraper detects each URL's type automatically and reuses that page's own filters (brand, price, sort, and so on). You can mix different page types in one run.

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

Type what you're looking for, for example 'gibson les paul' or 'boss ds-1'. No need to build a URL — each term runs as a Reverb search.

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

Limit results to a single gear category. Works with your search terms, or on its own to browse the whole category when you enter no search term or URL. When you paste a URL, its own category is used instead.

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

Only return listings in this condition.

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

Only return listings priced at or above this amount, in the selected currency. Leave empty for no minimum.

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

Only return listings priced at or below this amount, in the selected currency. Leave empty for no maximum.

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

Only return listings that can ship to this country.

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

Order in which results are collected. Applies to your search terms, or to a filter-only browse. URLs use their own sort order.

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

Currency used for prices in your results and for the price filters above.

## `maxResults` (type: `integer`):

Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (up to about 25,000 per search). Tip: start with 10-50 to test, then increase.

## Actor input object example

```json
{
  "startUrls": [
    "https://reverb.com/marketplace?query=fender%20stratocaster"
  ],
  "searchTerms": [
    "gibson les paul"
  ],
  "category": "all",
  "condition": "all",
  "shipsTo": "any",
  "sortBy": "relevance",
  "currency": "USD",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Key listing fields — title, brand, price, and condition.

## `detail` (type: `string`):

Full listing, pricing, shipping, and seller fields.

# 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 = {
    "startUrls": [
        "https://reverb.com/marketplace?query=fender%20stratocaster"
    ],
    "searchTerms": [
        "gibson les paul"
    ],
    "category": "all",
    "condition": "all",
    "shipsTo": "any",
    "sortBy": "relevance",
    "currency": "USD",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "startUrls": ["https://reverb.com/marketplace?query=fender%20stratocaster"],
    "searchTerms": ["gibson les paul"],
    "category": "all",
    "condition": "all",
    "shipsTo": "any",
    "sortBy": "relevance",
    "currency": "USD",
    "maxResults": 100,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://reverb.com/marketplace?query=fender%20stratocaster"
  ],
  "searchTerms": [
    "gibson les paul"
  ],
  "category": "all",
  "condition": "all",
  "shipsTo": "any",
  "sortBy": "relevance",
  "currency": "USD",
  "maxResults": 100
}' |
apify call solidcode/reverb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/reverb-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reverb Scraper",
        "description": "[💰 $5.00 / 1K] Extract new & used musical instrument listings from Reverb.com — guitars, amps, pedals, synths, drums, and pro audio gear. Get title, brand, model, year, price, condition, shipping, seller, images, and specs. Search by keyword or paste Reverb URLs.",
        "version": "1.0",
        "x-build-id": "IjFyX6d6hgtk6Zkz5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~reverb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-reverb-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~reverb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-reverb-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~reverb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-reverb-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Reverb URLs",
                        "type": "array",
                        "description": "Paste one or more Reverb.com URLs. Works with marketplace search result pages, category pages, and individual listing pages — the scraper detects each URL's type automatically and reuses that page's own filters (brand, price, sort, and so on). You can mix different page types in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Type what you're looking for, for example 'gibson les paul' or 'boss ds-1'. No need to build a URL — each term runs as a Reverb search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "electric-guitars",
                            "acoustic-guitars",
                            "bass-guitars",
                            "amps",
                            "effects-and-pedals",
                            "keyboards-and-synths",
                            "drums-and-percussion",
                            "pro-audio",
                            "dj-and-lighting-gear",
                            "home-audio",
                            "folk-instruments",
                            "band-and-orchestra",
                            "software",
                            "recorded-music",
                            "accessories",
                            "parts"
                        ],
                        "type": "string",
                        "description": "Limit results to a single gear category. Works with your search terms, or on its own to browse the whole category when you enter no search term or URL. When you paste a URL, its own category is used instead."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "all",
                            "used",
                            "new",
                            "mint",
                            "excellent",
                            "very-good",
                            "good",
                            "fair",
                            "poor",
                            "non-functioning",
                            "b-stock"
                        ],
                        "type": "string",
                        "description": "Only return listings in this condition."
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount, in the selected currency. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount, in the selected currency. Leave empty for no maximum."
                    },
                    "shipsTo": {
                        "title": "Ships To",
                        "enum": [
                            "any",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "JP"
                        ],
                        "type": "string",
                        "description": "Only return listings that can ship to this country."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Order in which results are collected. Applies to your search terms, or to a filter-only browse. URLs use their own sort order."
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "NZD",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "MXN"
                        ],
                        "type": "string",
                        "description": "Currency used for prices in your results and for the price filters above."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (up to about 25,000 per search). Tip: start with 10-50 to test, then increase."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
