# Musician's Friend Product Reviews Scraper (`automation-lab/musicians-friend-product-reviews-scraper`) Actor

🎸 Export public Musician's Friend reviews with ratings, text, votes, badges, tags, media, product identifiers, and rating rollups—without login.

- **URL**: https://apify.com/automation-lab/musicians-friend-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Musician's Friend Product Reviews Scraper

Export public Musician's Friend product reviews as clean, analysis-ready data.

Provide product URLs or PowerReviews page IDs and receive one dataset row per review, including review text, star rating, reviewer badges, helpful votes, tags, media, product identifiers, and rating rollups.

Use the Actor for scheduled reputation monitoring, product research, launch tracking, customer-feedback analysis, or feeding review data into your own dashboards and AI workflows.

### What does Musician's Friend Product Reviews Scraper do?

The Actor reads the public review feed displayed on Musician's Friend product pages.

It can:

- 🎸 Accept standard Musician's Friend product URLs
- 🔑 Accept direct product page IDs such as `L69991`
- 📝 Export individual review headlines and full review text
- ⭐ Capture ratings and product-level rating summaries
- ✅ Preserve verified buyer, verified reviewer, and staff-reviewer badges
- 👍 Collect helpful and not-helpful vote counts
- 🏷️ Extract pros, cons, and best-use tags
- 📷 Normalize review image and media URLs
- 🔢 Return UPC and GTIN product identifiers when available
- 📅 Sort reviews and limit results per product

The output is available in JSON, CSV, Excel, XML, RSS, and other Apify dataset formats.

### Who is it for?

#### Musical-instrument brands

Monitor how customers describe product quality, playability, tone, electronics, and value. Compare feedback across product launches and model generations.

#### Retail and ecommerce teams

Track rating changes, common use cases, and review volume for products in your category. Feed fresh reviews into assortment and merchandising analysis.

#### Product and reputation teams

Schedule recurring exports ordered by newest review. Detect fresh criticism, praise, product defects, and shifts in customer sentiment.

#### Market researchers

Build structured datasets for competitor benchmarking without manually copying review pages.

#### Data and AI teams

Send normalized review records to warehouses, vector databases, sentiment models, dashboards, or large-language-model workflows.

### Why use this Actor?

Manual review collection is slow and difficult to repeat. Page layouts are also inconvenient for analysis.

This Actor provides:

- **Structured rows:** one consistent record per public review
- **Repeatability:** rerun the same input or attach a schedule
- **Source context:** product ID, product URL, product name, UPC, and GTIN
- **Review detail:** body, headline, rating, badges, votes, tags, and media
- **Rollup context:** average rating, review count, recommendation ratio, and histogram
- **Integration-ready output:** use datasets, webhooks, API calls, or MCP
- **API-first mode:** page IDs bypass product-page resolution entirely

### What data can you extract?

| Field | Description |
|---|---|
| `reviewId` | Stable public review identifier |
| `productPageId` | Musician's Friend PowerReviews page ID |
| `productUrl` | Input product URL, when supplied |
| `productName` | Product name from the review rollup |
| `headline` | Review title |
| `body` | Full public review text |
| `nickname` | Public reviewer nickname |
| `location` | Public reviewer location, when supplied |
| `createdAt` | Review creation timestamp in ISO format |
| `updatedAt` | Review update timestamp in ISO format |
| `rating` | Star rating |
| `helpfulVotes` | Helpful vote count |
| `notHelpfulVotes` | Not-helpful vote count |
| `verifiedBuyer` | Verified-buyer badge flag |
| `verifiedReviewer` | Verified-reviewer badge flag |
| `staffReviewer` | Staff-reviewer badge flag |
| `pros`, `cons` | Structured product tags |
| `bestUses` | Structured best-use tags |
| `media` | Review media IDs, types, URLs, and captions |
| `upc`, `gtin` | Product identifiers when present |
| `averageRating` | Product average rating |
| `reviewCount` | Product review count |
| `recommendedRatio` | Product recommendation ratio |
| `ratingHistogram` | Counts for one through five stars |
| `scrapedAt` | Extraction timestamp |

### How to scrape Musician's Friend product reviews

1. Open the Actor in Apify Console.
2. Add one or more Musician's Friend product URLs.
3. Alternatively, enter direct page IDs under **PowerReviews page IDs**.
4. Choose the maximum reviews per product.
5. Select the review order.
6. Click **Start**.
7. Preview the product reviews in the Dataset tab.
8. Export the data or connect it to another service.

For a first test, keep the prefilled limit at 10. The sample product currently has a small, finite public review set, so a run may return fewer records than the configured maximum.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.musiciansfriend.com/guitars/fender-american-ultra-stratocaster-maple-fingerboard-electric-guitar/l69991000005000"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 10,
  "sort": "MostHelpful",
  "locale": "en_US"
}
```

#### Input options

| Option | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | sample URL | Musician's Friend product detail pages |
| `productIds` | array | `[]` | Direct public page IDs, for example `L69991` |
| `maxReviewsPerProduct` | integer | `50` | Review cap for each product, from 1 to 1,000 |
| `sort` | string | `MostHelpful` | Most helpful, newest, oldest, highest, or lowest rated |
| `locale` | string | `en_US` | Review locale in `language_COUNTRY` format |

At least one URL or page ID is required. Duplicate page IDs are processed once.

### Output example

```json
{
  "reviewId": "345316503",
  "productPageId": "L69991",
  "productName": "American Ultra Stratocaster Maple Fingerboard Electric Guitar",
  "headline": "Perfect right out of the box.",
  "body": "This is the new version of the American Deluxe Strat...",
  "nickname": "Roadrunner Bryce",
  "location": "Victorville, CA",
  "createdAt": "2021-05-21T18:02:51.859Z",
  "rating": 5,
  "helpfulVotes": 12,
  "notHelpfulVotes": 0,
  "verifiedBuyer": false,
  "pros": ["Good Feel", "Good Tone", "Great Neck"],
  "bestUses": ["Gigs", "Jamming", "Recording"],
  "media": [],
  "averageRating": 5,
  "reviewCount": 7,
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

Optional fields are omitted when the public source does not provide them. Required booleans, counters, tag arrays, media arrays, and rating histograms remain consistently typed.

### How much does it cost to scrape Musician's Friend reviews?

The Actor uses pay-per-event pricing:

- A small **$0.005 start fee** is charged once per run.
- Each saved review is charged at your Apify plan's tiered review price.
- Higher Apify plans receive lower per-review pricing.
- Failed targets do not produce or charge review events.

Apify shows the exact active event price before you start a run. You can control spend with `maxReviewsPerProduct` and a small product list.

### Sorting reviews

Choose the order that matches your workflow:

- `MostHelpful` for established, high-signal reviews
- `Newest` for recurring monitoring and launch tracking
- `Oldest` for chronological archives
- `HighestRating` for positive themes
- `LowestRating` for complaints, defects, and product risks

The sort is applied independently to every product.

### Product URLs and page IDs

A standard Musician's Friend product URL ends with a SKU-like segment. The Actor resolves its six-character review page ID prefix automatically.

For example, the URL ending in `l69991000005000` maps to page ID `L69991`.

Use `productIds` when:

- You already store Musician's Friend page IDs
- You want a compact API input
- You have an unusual URL that does not contain the standard ID prefix
- You are building a recurring product-monitoring pipeline

Only `musiciansfriend.com` URLs are accepted. Other domains fail closed rather than being silently treated as equivalent products.

### Scheduling a review monitor

Apify schedules can run this Actor hourly, daily, weekly, or on a custom cron expression.

A useful monitoring setup is:

1. Save a task with your important product URLs.
2. Set `sort` to `Newest`.
3. Choose a practical per-product limit.
4. Schedule the task.
5. Send finished-run data through a webhook.
6. Deduplicate records downstream by `reviewId`.

This creates a lightweight review-monitoring feed without running a browser.

### Integrations

Connect the dataset to:

- **Google Sheets:** maintain a product feedback tracker
- **Slack or email:** alert teams to new low-rating reviews
- **Make or Zapier:** automate review triage and routing
- **BigQuery or Snowflake:** join reviews with sales and catalog data
- **Power BI or Tableau:** chart ratings and common tags
- **S3 or cloud storage:** archive periodic snapshots
- **Webhooks:** trigger a workflow when each run finishes
- **AI pipelines:** summarize themes or classify product issues

Use `reviewId` as the downstream deduplication key and `productPageId` as the product grouping key.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/musicians-friend-product-reviews-scraper').call({
  productIds: ['L69991'],
  maxReviewsPerProduct: 20,
  sort: 'Newest',
  locale: 'en_US',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/musicians-friend-product-reviews-scraper').call(run_input={
    'productIds': ['L69991'],
    'maxReviewsPerProduct': 20,
    'sort': 'Newest',
    'locale': 'en_US',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~musicians-friend-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productIds": ["L69991"],
    "maxReviewsPerProduct": 20,
    "sort": "Newest",
    "locale": "en_US"
  }'
```

After the run succeeds, fetch records from its `defaultDatasetId`.

### Use with Apify MCP

Expose the Actor as a tool to Claude Code and other MCP clients through Apify's MCP server:

```bash
npx -y @apify/actors-mcp-server \
  --actors automation-lab/musicians-friend-product-reviews-scraper
```

For hosted MCP clients, use:

```text
https://mcp.apify.com/?tools=automation-lab/musicians-friend-product-reviews-scraper
```

Example prompts:

- “Export the newest reviews for Musician's Friend page ID L69991.”
- “Find recurring complaints in these Musician's Friend product reviews.”
- “Compare pros and best-use tags across my product URL list.”
- “Summarize reviews with ratings below four stars.”

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/musicians-friend-product-reviews-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this hosted MCP server in the MCP settings for Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/musicians-friend-product-reviews-scraper"
    }
  }
}
```

### Data quality notes

The Actor preserves public source values and normalizes timestamps and media URLs.

Keep these details in mind:

- A configured limit is a maximum, not a promised record count.
- Some products naturally have no reviews or fewer reviews than the limit.
- Optional reviewer location, badges, UPC, GTIN, tags, and media may be absent.
- Product-level rollups are repeated on review rows to simplify flat-file exports.
- Review edits can change `updatedAt` while retaining the same `reviewId`.
- Public reviews may be removed or moderated by the source.

### Performance and reliability

Review extraction uses Musician's Friend's public browser-facing JSON service rather than a full browser.

Benefits include:

- Low memory usage
- Fast startup
- Small network payloads
- Deterministic pagination
- No login or cookies
- No proxy required for the confirmed public route

Requests use bounded retries with backoff. Individual target failures are logged while other products continue. If every target fails, the Actor fails the run so automation does not mistake a total extraction outage for success.

### Limitations

- The Actor supports public Musician's Friend product reviews only.
- It does not submit reviews, vote, log in, or access private customer information.
- Standard product URLs must contain the Musician's Friend page ID prefix.
- Public merchant configuration or response fields can change over time.
- Review availability and moderation are controlled by Musician's Friend and PowerReviews.
- Ratings and rollups reflect the source at extraction time.
- A product with zero reviews returns an empty dataset for that target.

For unparseable product URLs, supply a direct `productIds` value.

### Is it legal to scrape Musician's Friend reviews?

This Actor accesses reviews that are publicly displayed without login.

You are responsible for your use of the data. Review applicable website terms, database rights, copyright rules, privacy laws, and your contractual obligations. Do not use public nicknames or locations to identify, profile, harass, or contact individuals. Avoid republishing full review text where your use lacks a lawful basis.

For legal advice about a specific use case, consult a qualified professional.

### FAQ and troubleshooting

#### Why did the Actor return fewer reviews than my limit?

`maxReviewsPerProduct` is a cap. The product may have fewer public reviews. Check `reviewCount` in returned rows for source context.

#### Why did my product URL fail?

Confirm it is a `musiciansfriend.com` product detail URL whose final path segment begins with a letter and five digits. If you know the page ID, put it in `productIds` instead.

#### Why is the dataset empty?

A valid product can have zero public reviews. Check the run log for the page ID and extracted count. If every target request fails, the run exits with an error instead of silently returning empty output.

#### Why are some fields missing?

Optional values are omitted when reviewers or the source did not supply them. Vote counts, badge flags, tag arrays, media arrays, ratings, and core identifiers retain stable types.

#### How do I avoid duplicate reviews across scheduled runs?

Deduplicate downstream by `reviewId`. For product-specific storage, use the pair `productPageId` and `reviewId`.

### Tips for better workflows

- Start with one product and 10 reviews.
- Use page IDs for compact automated inputs.
- Sort by newest for scheduled monitoring.
- Store the last-seen review IDs downstream.
- Use rating filters in your warehouse or spreadsheet after export.
- Keep source URL and GTIN fields when joining catalog data.
- Review failed target messages before retrying an unchanged URL.
- Batch related products in one run to reduce repeated start fees.

### Related scrapers

Build broader ecommerce and reputation workflows with other Automation Labs actors:

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [Steam Game Reviews Scraper](https://apify.com/automation-lab/steam-game-reviews-scraper)
- [Thomann Scraper](https://apify.com/automation-lab/thomann-scraper)

Choose this Actor when Musician's Friend is the required review source. Choose a related actor when you need another retailer's records; review IDs and source-specific schemas are not interchangeable.

### Support

If an input fails unexpectedly, share:

- The run URL
- The affected public product URL or page ID
- The expected review count or example
- The relevant log message

Do not include private account data or credentials. The Actor does not need them.

# Actor input Schema

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

One or more musiciansfriend.com product detail URLs.

## `productIds` (type: `array`):

Optional Musician's Friend page IDs such as L69991. Useful for API-first workflows.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews saved for each product. Use a small value for testing.

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

Order returned by Musician's Friend's public review service.

## `locale` (type: `string`):

PowerReviews locale in language\_COUNTRY format.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.musiciansfriend.com/guitars/fender-american-ultra-stratocaster-maple-fingerboard-electric-guitar/l69991000005000"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 10,
  "sort": "MostHelpful",
  "locale": "en_US"
}
```

# Actor output Schema

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

Open the default dataset and view one structured row per public Musician's Friend product review.

# 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.musiciansfriend.com/guitars/fender-american-ultra-stratocaster-maple-fingerboard-electric-guitar/l69991000005000"
        }
    ],
    "maxReviewsPerProduct": 10,
    "locale": "en_US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/musicians-friend-product-reviews-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.musiciansfriend.com/guitars/fender-american-ultra-stratocaster-maple-fingerboard-electric-guitar/l69991000005000" }],
    "maxReviewsPerProduct": 10,
    "locale": "en_US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/musicians-friend-product-reviews-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.musiciansfriend.com/guitars/fender-american-ultra-stratocaster-maple-fingerboard-electric-guitar/l69991000005000"
    }
  ],
  "maxReviewsPerProduct": 10,
  "locale": "en_US"
}' |
apify call automation-lab/musicians-friend-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/musicians-friend-product-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/VdoX9w6gn9EK914va/builds/sifOq5Et6wSbl1JGi/openapi.json