# Sweetwater.com Scraper (`lexis-solutions/sweetwater-com-scraper`) Actor

Scrapes product data from Sweetwater.com, including product details, pricing, and availability. Configurable to target specific categories or search results.

- **URL**: https://apify.com/lexis-solutions/sweetwater-com-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 products

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 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.com Scraper](https://i.postimg.cc/NfPy0nSz/image.png)

### What does Sweetwater.com Scraper do?

Sweetwater.com Scraper helps you search and extract product data from **sweetwater.com**, a leading US retailer for pro audio, music instruments, and studio gear.

You can extract product details such as title, brand, description, price, specs, review counts, stock/lead time, and product images from product listings and product pages. The Sweetwater.com Scraper supports REST API access to the extracted dataset, so you can download and use the results in other tools and workflows.

### Sweetwater.com Scraper

Sweetwater.com Scraper allows you to search and extract ecommerce product data from Sweetwater.com. The scraper supports REST API access for the output dataset, including multiple export formats for analytics, monitoring, and catalog enrichment use cases.

### What data can I extract from Sweetwater.com with a web scraper?

With this web scraping tool, you can extract the following data from Sweetwater.com:

<table>
<tr>
<td>Product title</td>
<td>Long description</td>
</tr>
<tr>
<td>Brand</td>
<td>Price</td>
</tr>
<tr>
<td>Rating data (average rating and count)</td>
<td>Featured image URL</td>
</tr>
</table>

### Why scrape Sweetwater.com?

Sweetwater.com is a major retailer for pro audio, music production, and studio equipment. Its listings contain rich product metadata, specs, and reviews that are useful for ecommerce intelligence, catalog enrichment, and price monitoring.

Whether you are a reseller, pricing analyst, catalog manager, or market researcher, scraping Sweetwater.com can help you:

- Monitor pricing and stock trends for music gear
- Track inventory changes for brands and categories
- Analyze product metadata and spec consistency
- Collect product-level details for comparison and research
- Build enriched datasets for ecommerce intelligence
- Identify market opportunities in pro audio and music tech

### How to use Sweetwater.com Scraper?

Sweetwater.com Scraper is designed for a fast setup, even if you have never scraped ecommerce websites before. Here is how to extract data from Sweetwater.com:

1. Create a free Apify account using your email.
2. Open Sweetwater.com Scraper on the Apify platform.
3. Click on the **Try for free** button.
4. Enter one or more start URLs (search/category pages and/or product detail pages).
5. Set `maxItems` based on how many products you want to collect.
6. Click on **Start** and wait for extraction to finish.
7. Download your data in JSON, XML, CSV, Excel, HTML, JSONL, or NDJSON.

### Input

The actor accepts the following input parameters:

- `startUrls` (array of objects) - **Required**. URLs to start with. You can provide both search/category URLs and individual product detail URLs.
- `maxItems` (integer) - Maximum number of products to scrape per start URL. Default: 3.
- `proxyConfiguration` (object) - Proxy configuration settings for crawling.

#### Supported URL Types

You can use both search, category, and individual product detail pages:

**Search Page Example:**

- `https://www.sweetwater.com/store/search?s=remote`

**Category Page Example:**

- `https://www.sweetwater.com/c695--Audio_Interfaces`

**Product Detail Page Example:**

- `https://www.sweetwater.com/store/detail/Scar2i22020Bn1--focusrite-scarlett-2i2-4th-gen-usb-audio-interface-and-at2020-vocal-recording-bundle`

Example:

```json
{
    "startUrls": [
        { "url": "https://www.sweetwater.com/store/search?s=remote" },
        { "url": "https://www.sweetwater.com/c695--Audio_Interfaces" },
        {
            "url": "https://www.sweetwater.com/store/detail/Scar2i22020Bn1--focusrite-scarlett-2i2-4th-gen-usb-audio-interface-and-at2020-vocal-recording-bundle"
        }
    ],
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

#### Note: The startUrls field is required

### Output

The scraped data is saved as a dataset. Each item represents one Sweetwater product. You can download the output in JSON, JSONL, HTML table, CSV, Excel spreadsheet, or NDJSON.

In the output below, you can see a preview of one dataset item. Actual fields may vary by product page completeness.

```json
{
    "title": "Focusrite Scarlett 2i2 4th Gen USB Audio Interface",
    "featuredImage": "https://media.sweetwater.com/m/products/image/b074a2e2f9uUlCGEMbPKO9pCL22iWPZkuboJ7ktD.jpg",
    "brand": "Focusrite",
    "ratingData": {
        "rating": 4.5,
        "ratingCount": 49
    },
    "price": 224.99,
    "longDescription": "USB Audio Interface with 2 Mic/Instrument/Line Inputs, 2 Line Outputs, 24-bit/192kHz Conversion, Air Mode, and Loopback"
}
```

#### Notes and Limitations

- The actor relies on the current structure of sweetwater.com. If the website structure changes, the actor may need updates.
- Use this actor in compliance with Sweetwater's terms of service and all applicable laws.
- Uses Residential proxy by default due to extensive blocking.

#### Looking to Scrape more Ecommerce Websites?

In addition to this actor, you can explore our suite of dedicated ecommerce scrapers. Each scraper is optimized for its target site to provide accurate, structured, and reliable data extraction.

| Scraper                                                                                      | Region        | Description                                                                                                                                                                                                                                                                                   |
| -------------------------------------------------------------------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Otto.de Scraper](https://apify.com/lexis-solutions/otto-de-scraper)                         | Germany       | The Otto.de Apify Scraper is an automated tool for extracting valuable data from Otto.de - one of the leading e-commerce platforms in Germany. It provides businesses with insights for market analysis, competitor monitoring, and price tracking. Ideal for e-commerce and market research. |
| [Poshmark.com Scraper](https://apify.com/lexis-solutions/poshmark-scraper)                   | Global        | Scrape product listings from Poshmark.com - including item names, prices, sizes, brands, seller info, and images. Ideal for market research, trend tracking, price comparison, and inventory insights. Fast, structured, and customizable extraction from a leading social commerce platform. |
| [Barnes and Noble Product Scraper](https://apify.com/lexis-solutions/barnesandnoble-scraper) | United States | Gather product details with the Barnes and Noble Product Scraper. Extract titles, authors, prices, and ISBNs directly from Barnes and Noble. Optimize your e-commerce strategy with accurate, up-to-date data.                                                                                |

Explore these solutions to expand your data collection capabilities across ecommerce websites.

***

p.s.

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners). We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:info@lexis.solutions) or [LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Image Credit

Image credit: https://www.sweetwater.com/

# Actor input Schema

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

URLs to start with.

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

Maximum number of items that will be extracted.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sweetwater.com/store/search?s=remote"
    }
  ],
  "maxItems": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.sweetwater.com/store/search?s=remote"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/sweetwater-com-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": [{ "url": "https://www.sweetwater.com/store/search?s=remote" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/sweetwater-com-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": [
    {
      "url": "https://www.sweetwater.com/store/search?s=remote"
    }
  ]
}' |
apify call lexis-solutions/sweetwater-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sweetwater.com Scraper",
        "description": "Scrapes product data from Sweetwater.com, including product details, pricing, and availability. Configurable to target specific categories or search results.",
        "version": "1.0",
        "x-build-id": "NdTMaTDoYVGf37TM2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~sweetwater-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-sweetwater-com-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/lexis-solutions~sweetwater-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-sweetwater-com-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/lexis-solutions~sweetwater-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-sweetwater-com-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "type": "integer",
                        "description": "Maximum number of items that will be extracted.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
