# MouthShut Reviews Scraper (`automation-lab/mouthshut-reviews-scraper`) Actor

Extract reviews, ratings, reviewer details, and engagement metrics from public MouthShut product and service pages.

- **URL**: https://apify.com/automation-lab/mouthshut-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 3 total users, 2 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

## MouthShut Reviews Scraper

Extract public product and service reviews from MouthShut into structured data.

Provide one or more MouthShut review-listing URLs and receive review text, star ratings, author context, timestamps, engagement counts, and entity-level reputation metrics.

The Actor is designed for recurring Indian-market reputation monitoring across ecommerce, finance, travel, mobile apps, employers, local services, and other categories represented on MouthShut.

### What does MouthShut Reviews Scraper do?

The Actor opens public MouthShut product review listings in a browser, waits for the review records rendered by the site, and follows numbered review pages.

Each dataset row represents one public review.

Entity context is repeated on every row so exports can be filtered, joined, or analyzed without a separate lookup table.

The Actor:

- accepts direct MouthShut product review URLs;
- supports multiple entities in one run;
- follows numbered pagination;
- deduplicates reviews by their public detail URL;
- extracts the full text available on the listing;
- records per-review ratings and engagement;
- records aggregate entity rating, vote count, and recommendation percentage;
- stops at explicit review and page limits;
- rejects unrelated URLs instead of scraping an unintended page.

It does not write reviews, sign in, or access private account data.

### Who is it for?

**Brand and reputation teams** can schedule daily or weekly collection and track new customer complaints.

**Customer experience teams** can inspect review text alongside star ratings and engagement signals.

**Ecommerce teams** can compare public sentiment for marketplaces, apps, sellers, and services.

**Competitive-intelligence analysts** can monitor several entities with the same repeatable schema.

**Data and AI teams** can export review text for sentiment classification, topic extraction, and alerting.

**Agencies** can build client-facing reputation reports without copying review cards manually.

### Why use this Actor?

MouthShut listing pages load review cards with JavaScript.

A simple HTTP downloader receives useful aggregate structured data but not the complete rendered review list.

This Actor handles that rendering step, pagination, record normalization, limits, and dataset export for you.

It runs without a login and only processes public review listings.

The browser blocks unnecessary media, fonts, advertising, and analytics requests to reduce runtime and transfer.

### What data can you extract?

| Field | Description |
| --- | --- |
| `entityName` | Reviewed product or service name |
| `entityUrl` | Canonical MouthShut review-listing URL |
| `categoryPath` | Available category breadcrumb labels |
| `aggregateRating` | Entity rating out of five |
| `aggregateRatingCount` | Number of aggregate votes |
| `recommendationPercent` | Percentage of members recommending the entity |
| `ratingDistribution` | Star counts when MouthShut exposes them; otherwise `null` |
| `reviewId` | Internal review identifier when present |
| `reviewUrl` | Public individual-review URL |
| `title` | Review title |
| `text` | Review body as plain text |
| `rating` | Review star rating out of five |
| `reviewerUsername` | Public reviewer username |
| `reviewerLocation` | Public location shown by MouthShut |
| `reviewerProfileUrl` | Public profile URL |
| `reviewerReviewCount` | Review count shown in the author summary |
| `publishedTime` | Date, time, or relative age displayed by MouthShut |
| `postedViaMobile` | Whether the listing marks a mobile submission |
| `likesCount` | Public like/usefulness count |
| `commentsCount` | Public comment count |
| `viewsCount` | Public view count |
| `sourceUrl` | Exact numbered listing page used |
| `scrapedAt` | UTC extraction timestamp |

Fields may be `null` when MouthShut does not expose that value for a particular entity or review.

### How to scrape MouthShut reviews

1. Open the Actor input form.
2. Add one or more public URLs containing `/product-reviews/`.
3. Set the maximum number of reviews needed across all URLs.
4. Set a page limit for each URL.
5. Click **Start**.
6. Open the **Dataset** tab to preview, download, or integrate the results.

A working input is:

```json
{
  "startUrls": [
    {
      "url": "https://www.mouthshut.com/product-reviews/amazon-reviews-925000493"
    }
  ],
  "maxReviews": 100,
  "maxPagesPerUrl": 5
}
```

### Input parameters

#### `startUrls`

Required array of public MouthShut product review listing URLs.

Both a main listing and a numbered URL ending in `-page-N` are accepted.

Up to 100 input URLs are supported in one run.

URLs outside `mouthshut.com`, mobile API links, profile pages, and individual review URLs are rejected.

#### `maxReviews`

Maximum number of unique review rows saved across the whole run.

Default: `100`.

Allowed range: `1` to `50,000`.

#### `maxPagesPerUrl`

Maximum number of listing pages visited from each input URL.

Default: `10`.

Allowed range: `1` to `2,500`.

MouthShut commonly shows 20 reviews per page, though the source controls the actual count.

### Output example

The default dataset contains one object per review:

```json
{
  "entityName": "Amazon",
  "entityUrl": "https://www.mouthshut.com/product-reviews/amazon-reviews-925000493",
  "categoryPath": ["Ecommerce and Online Business", "Online Shopping"],
  "aggregateRating": 2.97,
  "aggregateRatingCount": 206018,
  "recommendationPercent": 54,
  "ratingDistribution": null,
  "reviewId": "4300000",
  "reviewUrl": "https://www.mouthshut.com/review/amazon-review-abcdefghij",
  "title": "Convenient shopping experience",
  "text": "The ordering process was straightforward and delivery arrived on time.",
  "rating": 4,
  "reviewerUsername": "sampleuser123",
  "reviewerLocation": "Pune India",
  "reviewerProfileUrl": "https://www.mouthshut.com/sampleuser123",
  "reviewerReviewCount": 7,
  "publishedTime": "Jan 15, 2025 10:30 AM",
  "postedViaMobile": true,
  "likesCount": 3,
  "commentsCount": 1,
  "viewsCount": 950,
  "sourceUrl": "https://www.mouthshut.com/product-reviews/amazon-reviews-925000493",
  "scrapedAt": "2026-07-27T05:47:40.159Z"
}
```

Values change as MouthShut updates its pages.

### How much does it cost to scrape MouthShut reviews?

The Actor uses pay-per-event pricing.

A run has a **$0.003 start fee** and a review event for each dataset row.

The FREE-tier review price is **$0.000041071 per review**; paid-platform tiers decrease progressively for higher-volume users.

At the FREE-tier event price:

- 20 reviews cost about **$0.00382** including the start fee;
- 100 reviews cost about **$0.00711** including the start fee;
- 1,000 reviews cost about **$0.0441** including the start fee.

These examples describe Actor event charges.

Your Apify plan and platform usage terms still apply.

The run stops as soon as `maxReviews` is reached, which makes the requested volume predictable.

### Pagination, limits, and deduplication

The Actor starts at each supplied URL and discovers the next numbered page from MouthShut's pagination controls.

`maxPagesPerUrl` is applied independently to each starting URL.

`maxReviews` is a global output limit for the complete run.

If the same review appears through multiple supplied listings, its public review URL is used to avoid duplicate dataset rows.

Supplying a numbered page starts collection from that page rather than silently returning to page one.

### Reliability and failure behavior

The Actor waits for MouthShut's rendered review-listing container rather than relying on a fixed sleep.

A transient navigation or upstream failure is retried once with a fresh page.

Challenge pages and unrecognized layouts are treated as errors, not as successful runs with zero data.

A valid listing with no current reviews can legitimately produce an empty dataset.

Invalid URL hosts, unsupported paths, and out-of-range limits fail before scraping starts.

No residential proxy fallback is enabled in this version.

### Tips for efficient runs

Start with one page and 20 reviews while testing a new entity URL.

Increase `maxPagesPerUrl` only when historical depth is required.

Use separate scheduled tasks when different brands need different frequencies or limits.

Store the `reviewUrl` as your durable deduplication key downstream.

Treat `publishedTime` as source text: MouthShut sometimes displays relative values such as “12 days ago”.

Use `scrapedAt` to establish when that relative value was observed.

### Reputation-monitoring workflows

#### Daily complaint alerting

Schedule a small run for a brand, compare `reviewUrl` values with the previous export, and send new low-star rows to Slack or email.

#### Competitor benchmarking

Supply several same-category listing URLs and group output by `entityName` to compare ratings, review volume, recommendation percentage, and recurring topics.

#### Sentiment and topic analysis

Send the `title` and `text` fields to a language model or text-classification pipeline.

Retain the `reviewUrl` and `sourceUrl` so analysts can inspect public source context.

#### BI reporting

Export JSON, CSV, or Excel from the dataset, or connect the dataset API to a warehouse refresh.

### Run with the Apify API

Replace `YOUR_APIFY_TOKEN` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~mouthshut-reviews-scraper/runs?token=YOUR_APIFY_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.mouthshut.com/product-reviews/amazon-reviews-925000493"}],
    "maxReviews": 20,
    "maxPagesPerUrl": 1
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/mouthshut-reviews-scraper').call({
  startUrls: [{ url: 'https://www.mouthshut.com/product-reviews/amazon-reviews-925000493' }],
  maxReviews: 20,
  maxPagesPerUrl: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/mouthshut-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.mouthshut.com/product-reviews/amazon-reviews-925000493"}],
    "maxReviews": 20,
    "maxPagesPerUrl": 1,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify's MCP server:

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

#### Claude Desktop

Add this server object to your Claude Desktop MCP configuration.

#### Cursor

Add the same server object in Cursor's MCP settings.

#### VS Code

Add the same server object through your VS Code MCP extension or workspace MCP configuration.

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

Example prompts:

- “Collect the latest 100 reviews from this MouthShut listing and summarize repeated complaints.”
- “Monitor these three MouthShut brand pages and return only newly observed one-star reviews.”
- “Compare the recommendation percentage and top review themes for these competitor URLs.”

### Integrations

Dataset results can be consumed through:

- Apify API and webhooks;
- Google Sheets;
- Make;
- Zapier;
- Slack;
- cloud storage;
- Python and JavaScript clients;
- business-intelligence and data-warehouse pipelines.

Use an Actor run webhook when downstream processing should begin immediately after a successful run.

### Responsible use and legality

This Actor extracts information displayed publicly by MouthShut without authentication.

You are responsible for complying with applicable laws, MouthShut's terms, privacy rules, and your intended use of the data.

Do not use public reviewer information for harassment, discrimination, spam, identity profiling, or attempts to deanonymize users.

Collect only the fields and volume necessary for a legitimate purpose.

Consider retention limits and access controls when storing review text or public profile information.

This Actor is not affiliated with or endorsed by MouthShut.

### Limitations

MouthShut controls page availability, fields, and layout.

Some records omit location, engagement, review ID, or aggregate fields.

`ratingDistribution` remains `null` when the listing does not expose star-level counts.

Relative publication times are preserved rather than guessed into exact dates.

The Actor accepts review-listing URLs; it does not discover entity URLs from keyword searches.

It does not scrape login-only content, post reviews, submit votes, or reply as a brand.

### Troubleshooting

#### Why did my run reject a URL?

Use a public HTTPS listing URL containing `/product-reviews/` and ending in `-reviews-` plus the numeric entity ID.

Individual `/review/` URLs, user profiles, search pages, and mobile API endpoints are not valid inputs.

#### Why did I receive fewer rows than expected?

Check both limits.

The run stops at `maxReviews`, and each input URL stops at `maxPagesPerUrl`.

The source may also have fewer public reviews or may repeat records that the Actor deduplicates.

#### Why is `ratingDistribution` null?

MouthShut does not consistently expose counts for each star level on public listings.

The aggregate rating, vote count, recommendation percentage, and each review's own star rating remain available when displayed.

#### What should I do if MouthShut shows a challenge page?

Retry later rather than repeatedly launching runs.

Persistent challenge or layout failures are surfaced as run errors so stale or empty output is not mistaken for a valid result.

### Frequently asked questions

#### Can I scrape several products or services at once?

Yes. Add each supported review-listing URL to `startUrls`.

The global `maxReviews` limit applies across all of them.

#### Can I start from page 2?

Yes. A numbered `-page-N` URL is accepted and pagination continues from there.

#### Does the Actor open every review detail page?

No. The listing already displays the review fields shipped in this version, so avoiding extra detail navigations reduces runtime.

#### Can I schedule recurring runs?

Yes. Create an Apify task with the desired URLs and use a schedule appropriate for your monitoring workflow.

#### Is a proxy required?

No proxy was required for the current public route, and this version does not enable an automatic residential fallback.

### Related review-data Actors

- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for software product and review intelligence.
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) for company profiles and Trustpilot reviews.

Use separate Actors when a workflow needs source-specific fields, then combine their datasets downstream using canonical profile or review URLs.

### Support

If a supported public listing fails, include the exact input URL, run ID, expected review count, and observed error when requesting support.

Do not include account credentials or private information.

# Actor input Schema

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

Public URLs such as https://www.mouthshut.com/product-reviews/amazon-reviews-925000493. Product listing and numbered page URLs are supported.

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

Maximum number of unique review records to save across all supplied URLs.

## `maxPagesPerUrl` (type: `integer`):

Safety limit for pagination from each supplied listing URL. MouthShut normally displays 20 reviews per page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.mouthshut.com/product-reviews/amazon-reviews-925000493"
    }
  ],
  "maxReviews": 20,
  "maxPagesPerUrl": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing the extracted review records.

# 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.mouthshut.com/product-reviews/amazon-reviews-925000493"
        }
    ],
    "maxReviews": 20,
    "maxPagesPerUrl": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/mouthshut-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.mouthshut.com/product-reviews/amazon-reviews-925000493" }],
    "maxReviews": 20,
    "maxPagesPerUrl": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/mouthshut-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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.mouthshut.com/product-reviews/amazon-reviews-925000493"
    }
  ],
  "maxReviews": 20,
  "maxPagesPerUrl": 10
}' |
apify call automation-lab/mouthshut-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/mouthshut-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/87PtnQdRiXWjvEcYb/builds/NDt5sALbOaUl1rLQy/openapi.json