# Best Buy Reviews Scraper (`automation-lab/best-buy-reviews-scraper`) Actor

🛍️ Extract public Best Buy customer reviews by URL or SKU with ratings, text, authors, dates, votes, recommendations, media, and source links.

- **URL**: https://apify.com/automation-lab/best-buy-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 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

## Best Buy Reviews Scraper

Extract public Best Buy customer reviews into structured JSON, CSV, Excel, or API-ready datasets. Supply product URLs or SKUs and receive one record per review—without maintaining a browser crawler.

Use the scraper for recurring reputation monitoring, product research, competitive analysis, and review-quality audits.

### What does Best Buy Reviews Scraper do?

The Actor reads Best Buy's public review feed and converts each customer review into a clean dataset row.

It supports:

- Best Buy product URLs and SKU IDs
- Multiple products per run
- Newest-first or oldest-first ordering
- Configurable review limits
- Ratings, review copy, authors, dates, votes, recommendations, and media
- Automatic pagination and duplicate protection

### Who is it for?

#### Brands and manufacturers

Monitor customer feedback after launches, compare product generations, and identify recurring complaints.

#### Marketplace sellers

Track sentiment and language customers use when describing products in your category.

#### Product researchers

Build review corpora for feature analysis, positioning research, or product comparison.

#### Reputation teams

Collect review deltas on a schedule and route low ratings into alerts or dashboards.

#### Data teams

Export predictable records into warehouses, spreadsheets, BI tools, or NLP pipelines.

### Why use this Actor?

- **HTTP-first:** no browser overhead for the public review surface.
- **Structured:** one consistent row per review.
- **Repeatable:** schedule runs to collect new feedback.
- **Flexible:** start from URLs, SKUs, or both.
- **Integrated:** use datasets, webhooks, API, Make, Zapier, or MCP.

### How to scrape Best Buy reviews

1. Open the Actor input page.
2. Add one or more Best Buy SKUs or product URLs.
3. Choose `newest` or `oldest` ordering.
4. Set the maximum number of reviews.
5. Click **Start**.
6. Export the dataset in your preferred format.

### Input

| Field | Type | Description |
|---|---|---|
| `productIds` | string[] | Best Buy SKU IDs |
| `startUrls` | request list | Best Buy product URLs |
| `maxReviews` | integer | Maximum rows across products |
| `sort` | string | `newest` or `oldest` |

At least one valid SKU or URL is required.

### Input example

```json
{
  "productIds": ["6418599"],
  "maxReviews": 100,
  "sort": "newest"
}
````

You can also use a product URL:

```json
{
  "startUrls": [{
    "url": "https://www.bestbuy.com/site/apple-macbook-air/6418599.p?skuId=6418599"
  }],
  "maxReviews": 50
}
```

### Output data

| Field | Description |
|---|---|
| `productId` | Best Buy SKU |
| `reviewId` | Stable review identifier |
| `title` | Review headline |
| `text` | Full review copy |
| `rating` | Numeric star rating |
| `reviewerNickname` | Public reviewer nickname |
| `date` | Published date |
| `recommended` | Recommendation status when available |
| `helpfulVotes` | Helpful vote count |
| `unhelpfulVotes` | Unhelpful vote count |
| `mediaUrls` | Customer media URLs |
| `syndicated` | Whether the review is syndicated |
| `sourceUrl` | Best Buy product review URL |
| `scrapedAt` | Extraction timestamp |

### Output example

```json
{
  "productId": "6418599",
  "reviewId": "425532631",
  "title": "The Best Purchase I Made in 2023?",
  "text": "I've had my Apple MacBook since 2023...",
  "rating": 5,
  "reviewerNickname": "JasmineC",
  "date": "2026-05-14",
  "recommended": true,
  "helpfulVotes": 3,
  "unhelpfulVotes": 0,
  "mediaUrls": [],
  "syndicated": false,
  "sourceUrl": "https://www.bestbuy.com/site/6418599.p?skuId=6418599#tabbed-customerreviews",
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

### How much does it cost to scrape Best Buy reviews?

Pricing is pay per event: a small run-start fee plus a charge for each review saved. Apify plan tiers receive volume discounts. The Console displays the exact live price before a run.

HTTP extraction keeps compute usage low. Set `maxReviews` to control run size and cost.

### Scheduling review monitoring

Create an Apify schedule with `sort: "newest"`. Save review IDs in your downstream system and process only unseen records. Daily or weekly schedules work well for active products.

### Filtering and sentiment workflows

Export all reviews, then filter by rating, date, recommendation, or product ID. Send review text to an NLP model to classify topics, sentiment, defects, or purchase intent.

### Integrations

- Send low-star reviews to Slack through a webhook.
- Append new reviews to Google Sheets with Make.
- Load datasets into BigQuery, Snowflake, or S3.
- Trigger Zapier workflows after successful runs.
- Read dataset items from your own application using `apify-client`.

### API usage

Run the Actor programmatically with JavaScript, Python, or cURL. Each call returns a run whose default dataset contains the review records.

#### 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/best-buy-reviews-scraper').call({
  productIds: ['6418599'],
  maxReviews: 100,
  sort: 'newest',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/best-buy-reviews-scraper').call(run_input={
    'productIds': ['6418599'],
    'maxReviews': 100,
    'sort': 'newest',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~best-buy-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"productIds":["6418599"],"maxReviews":100,"sort":"newest"}'
```

### Use with Apify MCP

Connect Claude Code or another MCP client to:

```text
https://mcp.apify.com?tools=automation-lab/best-buy-reviews-scraper
```

Example prompts:

- “Collect the 100 newest reviews for Best Buy SKU 6418599.”
- “Compare common complaints across these three Best Buy products.”
- “Export low-rated reviews and summarize recurring defects.”

### Data quality

Review IDs prevent duplicates within a run. Values are normalized into stable types, whitespace is cleaned, and extraction timestamps make recurring datasets auditable.

Public reviews can be edited or removed by their source. Re-run when freshness matters.

### Performance tips

- Use SKUs when available for the simplest input.
- Start with a low limit to validate a product.
- Group several SKUs in one run to reduce start-fee overhead.
- Use newest-first sorting for monitoring.
- Export only fields needed by downstream systems.

### Troubleshooting

#### Why did my run return no reviews?

Confirm the SKU exists and has public customer reviews. A product URL must contain a numeric Best Buy SKU.

#### Why are fewer reviews returned than requested?

The product may contain fewer public reviews, or the public feed may stop exposing older pages.

#### Why is recommendation null?

Best Buy does not publish a recommendation answer for every review.

### Limits

The Actor targets public Best Buy review pages. It does not scrape account-only content, reviewer private details, product inventory, search results, or checkout data.

Best Buy may change its public markup. Report extraction changes through the Actor issue form.

### Legality

#### Is scraping Best Buy reviews legal?

The Actor accesses publicly available review content. Your use must comply with applicable laws, Best Buy's terms, privacy rules, and intellectual-property requirements. Avoid republishing personal data or copyrighted review text without a lawful basis. This is not legal advice.

### FAQ

#### Does it require a Best Buy account?

No. The supported public review surface is anonymous.

#### Can I scrape several products?

Yes. Add multiple SKUs or URLs and set a combined maximum.

#### Can I sort reviews?

Yes. Choose newest-first or oldest-first.

#### Can I export CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, and RSS exports.

#### Does it use a browser?

No. It uses lightweight HTTP requests for the public review feed.

### Related scrapers

Explore other review and commerce Actors from [automation-lab](https://apify.com/automation-lab), including Walmart Reviews Scraper, Amazon Reviews Scraper, Airbnb Reviews Scraper, and Booking.com Reviews Scraper.

### Support

Use the Actor issue form with a sample public SKU, expected result, and run ID. Do not include credentials or private customer information.

# Actor input Schema

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

Best Buy SKU/product IDs, for example 6418599.

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

Best Buy product URLs. You can combine these with SKUs.

## `maxReviews` (type: `integer`):

Maximum review rows across all products.

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

Return newest or oldest reviews first.

## Actor input object example

```json
{
  "productIds": [
    "6418599"
  ],
  "maxReviews": 20,
  "sort": "newest"
}
```

# Actor output Schema

## `overview` (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 = {
    "productIds": [
        "6418599"
    ],
    "maxReviews": 20,
    "sort": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/best-buy-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 = {
    "productIds": ["6418599"],
    "maxReviews": 20,
    "sort": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/best-buy-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 '{
  "productIds": [
    "6418599"
  ],
  "maxReviews": 20,
  "sort": "newest"
}' |
apify call automation-lab/best-buy-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Buy Reviews Scraper",
        "description": "🛍️ Extract public Best Buy customer reviews by URL or SKU with ratings, text, authors, dates, votes, recommendations, media, and source links.",
        "version": "0.1",
        "x-build-id": "TPdJdk22uqaeUJmqf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~best-buy-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-best-buy-reviews-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/automation-lab~best-buy-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-best-buy-reviews-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/automation-lab~best-buy-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-best-buy-reviews-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": {
                    "productIds": {
                        "title": "🛍️ Best Buy SKUs",
                        "type": "array",
                        "description": "Best Buy SKU/product IDs, for example 6418599.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Best Buy product URLs",
                        "type": "array",
                        "description": "Best Buy product URLs. You can combine these with SKUs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum review rows across all products.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Return newest or oldest reviews first.",
                        "default": "newest"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
