# Sweetwater Scraper (`crawlerbros/sweetwater-scraper`) Actor

Scrape Sweetwater.com - the leading online music gear retailer. Search products by keyword, browse by category, filter by brand, price, and stock status. Extracts product name, brand, SKU, price, ratings, reviews, features, and more.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Sweetwater Scraper

Scrape **Sweetwater.com** — the USA's leading online music instrument and pro audio retailer. Search products by keyword or browse by category. Extracts product name, brand, SKU, price, stock status, ratings, reviews, and more.

### What this actor does

- **Search mode** — find products by keyword (e.g., `electric guitar`, `fender stratocaster`, `studio microphone`, `drum kit`)
- **Browse mode** — browse a specific category (Electric Guitars, Microphones, Audio Interfaces, etc.)
- **Filter** — narrow results by brand, price range (USD), and in-stock status
- **Pagination** — automatically pages through all results up to your `maxItems` limit

No authentication required. Uses TLS fingerprint impersonation (curl_cffi chrome131) to bypass basic bot detection.

### Output fields

Each product record contains:

| Field | Type | Description |
|---|---|---|
| `name` | string | Product name |
| `brand` | string | Manufacturer/brand name |
| `productType` | string | Generic product-type label (e.g., `Guitar Electric Semi-Hollow`, `Microphone Condenser`) |
| `sku` | string | Sweetwater item ID (e.g., `LPS6B8NH`) |
| `upc` | string | Manufacturer UPC/EAN barcode |
| `url` | string | Full product page URL |
| `imageUrl` | string | Product image URL (full-resolution product photo) |
| `description` | string | Full product description |
| `price` | number | Current price in USD |
| `regularPrice` | number | Original price (only present if discounted) |
| `currency` | string | Always `"USD"` |
| `inStock` | boolean | Whether the product is currently in stock |
| `condition` | string | Item condition: `"New"`, `"Used"`, etc. |
| `hasFreeShipping` | boolean | Whether the product ships free |
| `rating` | number | Average star rating (1–5) |
| `reviewCount` | integer | Total number of customer reviews |
| `category` | string | Top-level product category (e.g., `Guitars`) |
| `subcategory` | string | Subcategory (e.g., `Electric Guitars`, `Solidbody Guitars`) |
| `specialOffer` | string | Promotional offer text, when the product has one (e.g., `Free Eminence IR Sampler Pack! Only at Sweetwater!`) |
| `sweetwaterExclusive` | boolean | Whether it's a Sweetwater Exclusive product |
| `sourceUrl` | string | URL of the page this product was scraped from |
| `scrapedAt` | string | UTC ISO timestamp of when the record was scraped |
| `recordType` | string | Always `"product"` |

### Input options

#### Mode: `search` (default)

Search for products using a keyword.

```json
{
  "mode": "search",
  "searchQuery": "fender stratocaster",
  "brand": "Fender",
  "minPrice": 500,
  "maxPrice": 2000,
  "inStockOnly": true,
  "maxItems": 50
}
````

#### Mode: `byCategory`

Browse products in a specific category.

```json
{
  "mode": "byCategory",
  "category": "microphones",
  "brand": "Shure",
  "maxItems": 100
}
```

#### Available categories

`electric-guitars`, `acoustic-guitars`, `bass-guitars`, `guitar-amplifiers`, `bass-amplifiers`, `drums-percussion`, `keyboards`, `synthesizers`, `midi-controllers`, `microphones`, `headphones`, `studio-monitors`, `audio-interfaces`, `mixers`, `effects-pedals`, `recording-software`, `dj-equipment`, `live-sound`, `cables`, `stands-racks`, `lighting`

#### Sort options (both modes)

| Value | Description |
|---|---|
| `popular` (default) | Most popular |
| `price-asc` | Price: Low to High |
| `price-desc` | Price: High to Low |
| `rating` | Best Rated |
| `newest` | Newest first |

### Example output

```json
{
  "name": "Gibson Les Paul Standard '60s Electric Guitar - Bourbon Burst",
  "brand": "Gibson",
  "sku": "LPS6B8NH",
  "url": "https://www.sweetwater.com/store/detail/LPS6B8NH--gibson-les-paul-standard-60s-bourbon-burst",
  "imageUrl": "https://media.sweetwater.com/m/products/image/92977dcb6fa.png",
  "price": 2799,
  "currency": "USD",
  "inStock": true,
  "rating": 5,
  "reviewCount": 94,
  "category": "Guitars",
  "subcategory": "Solidbody Guitars",
  "sweetwaterExclusive": false,
  "sourceUrl": "https://www.sweetwater.com/shop/guitars/electric-guitars/",
  "scrapedAt": "2026-06-30T12:00:00+00:00",
  "recordType": "product"
}
```

### Use cases

- **Price monitoring** — Track price changes for specific brands or product types
- **Inventory tracking** — Monitor stock status for popular gear
- **Market research** — Analyze product assortment in different music gear categories
- **Competitor analysis** — Compare Sweetwater pricing vs. other retailers
- **Gift research** — Find guitars, keyboards, microphones, or studio gear within budget

### FAQ

**Q: Does this need a Sweetwater account?**
A: No. All scraped data is publicly available on sweetwater.com without login.

**Q: How many products can I get?**
A: Set `maxItems` up to 500. Sweetwater typically has hundreds to thousands of products per category.

**Q: Can I filter by specific brands?**
A: Yes — use the `brand` field. Example: `"brand": "Fender"` will match products where the brand or name contains "Fender" (case-insensitive).

**Q: Why might I get fewer results than expected?**
A: Some categories may have fewer in-stock products if `inStockOnly` is `true`, or your brand/price filters may be narrow.

**Q: Does this support international pricing?**
A: Sweetwater ships within the USA and prices are always in USD.

### Data source

This actor scrapes publicly available product listing pages on [sweetwater.com](https://www.sweetwater.com). Sweetwater is a registered trademark of Sweetwater Sound, Inc. This actor is not affiliated with or endorsed by Sweetwater.

# Actor input Schema

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

Search by keyword or browse a specific category.

## `searchQuery` (type: `string`):

Free-text search query for products (e.g. `electric guitar`, `fender stratocaster`, `studio microphone`).

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

Product category to browse on Sweetwater.

## `brand` (type: `string`):

Filter results to a specific brand (e.g. `Fender`, `Gibson`, `Shure`, `Yamaha`). Case-insensitive substring match.

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

Only include products priced at or above this value (in USD).

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

Only include products priced at or below this value (in USD).

## `inStockOnly` (type: `boolean`):

When enabled, only include products that are currently in stock.

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

How to sort search results. Applies to both search and category modes.

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

Maximum number of products to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "electric guitar",
  "category": "electric-guitars",
  "inStockOnly": false,
  "sortBy": "popular",
  "maxItems": 20
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Sweetwater products.

# 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",
    "searchQuery": "electric guitar",
    "category": "electric-guitars",
    "inStockOnly": false,
    "sortBy": "popular",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/sweetwater-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",
    "searchQuery": "electric guitar",
    "category": "electric-guitars",
    "inStockOnly": False,
    "sortBy": "popular",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/sweetwater-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 '{
  "mode": "search",
  "searchQuery": "electric guitar",
  "category": "electric-guitars",
  "inStockOnly": false,
  "sortBy": "popular",
  "maxItems": 20
}' |
apify call crawlerbros/sweetwater-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sweetwater Scraper",
        "description": "Scrape Sweetwater.com - the leading online music gear retailer. Search products by keyword, browse by category, filter by brand, price, and stock status. Extracts product name, brand, SKU, price, ratings, reviews, features, and more.",
        "version": "1.0",
        "x-build-id": "Yy1Jdxb7cFm8n9q4r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~sweetwater-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-sweetwater-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/crawlerbros~sweetwater-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-sweetwater-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/crawlerbros~sweetwater-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-sweetwater-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "Search by keyword or browse a specific category.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text search query for products (e.g. `electric guitar`, `fender stratocaster`, `studio microphone`).",
                        "default": "electric guitar"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "electric-guitars",
                            "acoustic-guitars",
                            "bass-guitars",
                            "guitar-amplifiers",
                            "bass-amplifiers",
                            "drums-percussion",
                            "keyboards",
                            "synthesizers",
                            "midi-controllers",
                            "microphones",
                            "headphones",
                            "studio-monitors",
                            "audio-interfaces",
                            "mixers",
                            "effects-pedals",
                            "recording-software",
                            "dj-equipment",
                            "live-sound",
                            "cables",
                            "stands-racks",
                            "lighting"
                        ],
                        "type": "string",
                        "description": "Product category to browse on Sweetwater.",
                        "default": "electric-guitars"
                    },
                    "brand": {
                        "title": "Brand filter",
                        "type": "string",
                        "description": "Filter results to a specific brand (e.g. `Fender`, `Gibson`, `Shure`, `Yamaha`). Case-insensitive substring match."
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only include products priced at or above this value (in USD)."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only include products priced at or below this value (in USD)."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "When enabled, only include products that are currently in stock.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popular",
                            "price-asc",
                            "price-desc",
                            "rating",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort search results. Applies to both search and category modes.",
                        "default": "popular"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
