# Watsons Reviews Scraper (`stealth_mode/watsons-reviews-scraper`) Actor

Scrape customer reviews from Watsons.com (all regional sites: .com.my, .co.th, etc.). Extract ratings, comments, customer data, approval status, and 10+ fields per review — perfect for sentiment analysis, market research, and reputation monitoring.

- **URL**: https://apify.com/stealth\_mode/watsons-reviews-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## Watsons Reviews Scraper: Extract Product Reviews & Customer Feedback

---

### Understanding Watsons & Review Data Importance

Watsons is a leading health and beauty retailer operating across Southeast Asia and beyond, with localized sites in Malaysia (.com.my), Thailand (.co.th), and other countries. Customer reviews are critical assets for understanding product performance, consumer sentiment, and brand reputation. Manually collecting reviews from product pages is impractical at scale — the **Watsons Reviews Scraper** automates this, transforming review data into structured, analyzable records ideal for research, competitive intelligence, and customer insights.

---

### Scraper Overview

The **Watsons Reviews Scraper** extracts detailed customer reviews and comments from individual product pages across Watsons regional sites. It captures not just ratings and text, but metadata about each review including approval status, customer anonymity, engagement metrics, and reportability flags.

**Best suited for:**
- E-commerce managers analyzing product performance
- Market researchers studying consumer preferences in beauty and health
- Brand strategists monitoring reputation across regions
- Data analysts building sentiment datasets
- Competitive benchmarking professionals

The scraper handles multiple product URLs, supports customizable collection limits, and gracefully continues operation even if individual URLs fail — ensuring reliable bulk extraction workflows.

---

### Input Format

The scraper accepts a JSON configuration controlling which products to target and how to collect reviews:

```json
{
  "urls": [
    "https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465"
  ],
  "max_items_per_url": 200,
  "ignore_url_failures": true
}
````

#### Input Parameters Explained

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array of strings | Direct links to Watsons product detail pages. Copy the full product URL from any regional site (e.g., .com.my, .co.th, .com.sg). Each URL should point to an individual product page containing reviews. |
| `max_items_per_url` | Integer | Maximum number of reviews to extract per product URL (e.g., `200`). Higher values collect more reviews but increase runtime. Typical product pages contain 20–500+ reviews. |
| `ignore_url_failures` | Boolean | If `true`, the scraper skips failed URLs and continues processing remaining ones. If `false`, a single failed URL stops the entire run. Recommended `true` for bulk extraction to ensure robustness. |

> **Pro tip:** Regional Watsons sites share similar review structures, so you can mix URLs from different countries (e.g., Malaysia and Thailand) in a single run.

***

### Output Format

**Sample output**

```json
{
  "alias": "Y**",
  "approval_status": "APPROVED",
  "comment": "Fast delivery, good quality and packing ",
  "customer_hash_id": "5BF73DA99F8994ACD196F8891F915892EA4238F9DFF5C723D44CFD5BAD0CE208",
  "date": "2025-01-31T15:40:20+0000",
  "headline": "review-48465-WTCMY90502285",
  "id": "9103422816305",
  "is_show_my_name": false,
  "like": 0,
  "rating": 5.0,
  "reply_count": 0,
  "reportable": true,
  "tagged_comment": "Fast delivery, good quality and packing ",
  "vp_code": "48465",
  "from_url": "https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465?ajax=true"
}
```

Each review record contains 10+ structured fields capturing the complete review context:

#### Review Identification

| Field | Description |
|---|---|
| `ID` | Unique identifier for the review within Watsons' system |
| `Alias` | The display name or username of the reviewer (may be anonymized) |
| `Is Show My Name` | Boolean flag: `true` if the reviewer chose to show their real name, `false` if anonymous |
| `Customer Hash ID` | Anonymized customer identifier for tracking repeat reviewers without exposing identity |

#### Review Content

| Field | Description |
|---|---|
| `Headline` | Short summary title of the review (e.g., "Great for sensitive skin") |
| `Comment` | Full text of the customer's review |
| `Rating` | Star rating given by the reviewer (typically 1–5 stars) |
| `Date` | Timestamp when the review was posted |

#### Review Status & Moderation

| Field | Description |
|---|---|
| `Approval Status` | Moderation status of the review (e.g., `approved`, `pending`, `rejected`). Approved reviews are visible to all users. |
| `Reportable` | Boolean flag: `true` if the review can be reported as inappropriate or spam, `false` otherwise. |
| `Tagged Comment` | Label or tag applied to the review (e.g., "verified purchase," "helpful," or category tags from Watsons' taxonomy). |

#### Engagement & Interaction

| Field | Description |
|---|---|
| `Like` | Count of helpful votes or "likes" the review has received from other customers |
| `Reply Count` | Number of responses or replies to this review (e.g., seller responses or customer discussions) |

#### Additional Metadata

| Field | Description |
|---|---|
| `VP Code` | Vendor or product code identifier linking the review to specific inventory or seller records; used internally for analytics |

***

### How to Use

1. **Identify product URLs** — Navigate to Watsons.com (or regional variants) and open any product detail page. Copy the full URL from your browser address bar.
2. **Prepare your input** — Paste one or more product URLs into the `urls` array. You can add 1 URL or 100+.
3. **Set collection limits** — Adjust `max_items_per_url` (default `20`, range up to `200+`). Higher values collect more reviews per product.
4. **Enable fault tolerance** — Set `ignore_url_failures: true` to skip broken URLs without stopping the entire run.
5. **Start the scraper** — Launch the actor and monitor progress in the execution logs.
6. **Download results** — Export as JSON, CSV, or Excel for analysis.

**Troubleshooting tips:**

- Ensure URLs point to product *detail* pages, not search results or category pages.
- If reviews appear incomplete, the product may have fewer reviews than your `max_items_per_url` setting.
- Regional sites (Malaysia, Thailand, Singapore) may have slight variations in review field availability.

***

### Business Applications & ROI

- **Product insights:** Identify strengths and pain points across product lines and regions
- **Sentiment analysis:** Aggregate ratings and text to gauge customer satisfaction trends
- **Competitive monitoring:** Compare review counts and ratings vs. competing brands
- **Inventory optimization:** Identify under-performing products based on negative review patterns
- **Localization research:** Compare customer feedback across regional Watsons sites to inform regional strategies

The **Watsons Reviews Scraper** transforms raw customer voices into actionable business intelligence, reducing manual review collection by 99% and enabling data-driven decision-making.

***

### Conclusion

The **Watsons Reviews Scraper** is an essential tool for any organization seeking to understand customer sentiment and product performance across Watsons regional markets. With 10+ data fields, flexible multi-URL support, and robust error handling, it delivers clean, immediately actionable data. Start collecting product reviews today and gain competitive edge through customer insights.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/watsons-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 = {
    "urls": ["https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/watsons-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 '{
  "urls": [
    "https://www.watsons.com.my/laurier-super-slimguard-night-35cm-12s/p/BP_48465"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/watsons-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Watsons Reviews Scraper",
        "description": "Scrape customer reviews from Watsons.com (all regional sites: .com.my, .co.th, etc.). Extract ratings, comments, customer data, approval status, and 10+ fields per review — perfect for sentiment analysis, market research, and reputation monitoring.",
        "version": "0.0",
        "x-build-id": "IEX9i8335KWUBrVRh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~watsons-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-watsons-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/stealth_mode~watsons-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-watsons-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/stealth_mode~watsons-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-watsons-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": {
                    "urls": {
                        "title": "URLs of the product details urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
