# Mouthshut Scraper \[$3/1K💰] | India Reviews | Pros & Cons (`ahmed_jasarevic/mouthshut-scraper`) Actor

Scrape Mouthshut.com product ratings and customer reviews from India's largest review platform: MouthShut Score, star ratings, pros and cons, reviewer location and verified flags. Export JSON for reputation monitoring and India market research.

- **URL**: https://apify.com/ahmed_jasarevic/mouthshut-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 reviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Mouthshut Scraper — India Product Reviews & Ratings API

Scrape **Mouthshut.com** business/product ratings and individual reviews for reputation monitoring, India market research and D2C brand tracking. Give it product URLs (or a Mouthshut search URL) and it returns every review's star rating, author, location, verdict and **Pros/Cons**, plus a product-level summary row with the **MouthShut Score**, average rating and vote count.

### Main use cases

- **Brand reputation monitoring** — schedule recurring scrapes of your products and watch ratings, review volume and Pro/Con themes change over time.
- **India market research** — collect consumer sentiment for any category or competitor across India's largest review platform.
- **Product feedback analysis** — export reviews with Pros/Cons split out for sentiment analysis and voice-of-customer reporting.
- **D2C brand tracking** — track your brand (and rivals) on score, average rating and verified-review flags.
- **Review database building** — build a structured, joinable dataset of reviews for BI tools and dashboards.

### How it works

Mouthshut is a classic **ASP.NET WebForms** site with no public JSON API, so the actor reads the server-rendered HTML and the site's own internal AJAX endpoints — **no browser, no JavaScript rendering**. A product page carries the business name, MouthShut Score, average rating and vote count in plain HTML; individual reviews are lazy-loaded by the site's frontend through `GET /Review/rar_reviews.aspx`, which the actor calls directly (**20 reviews per light request**). You can also hand it **search URLs** instead of product URLs: the actor opens the search listing, collects the products it finds and scrapes their reviews in the same run. It is a **CheerioCrawler** at **256 MB** — roughly 10× cheaper on compute than a browser.

### Extract India Product Reviews For Brand Reputation Monitoring

Each run writes **one dataset per data type**:

| Dataset (alias) | Contents | Billing |
|---|---|---|
| `default` — **reviews** | One row per review (`recordType: "review"`): rating, date, author, body/pros/cons, views, permalink. | **Primary.** Charged one `apify-default-dataset-item` event per review. |
| `products` | One summary row per scraped product (`recordType: "product"`): name, category, MouthShut Score %, average rating, votes, rating distribution of the scraped sample, `foundThroughSearch`. | **Secondary.** Charged a `product-summary` event per product. |

Both are surfaced on the run page through the output schema (`Reviews` and `Products`), and the `OUTPUT` key-value record holds the run summary: `reviewCount`, `productCount`, `discoveredFromSearch`, `reviewsDatasetId` and `productsDatasetId`.

**Product summary** carries: business/product name, category + subcategory, MouthShut Score %, overall average rating, total votes, verified-brand flag and the rating distribution of the scraped sample.

**Individual reviews** carry: title, star rating (1–5), date, reviewer name/location/profile and review count, verified-member and verified-review flags, brand-responded flag, submission channel (Mobile / Android App), full body text split into **body / pros / cons**, view and comment counts, and the review permalink.

### Build A Mouthshut Reviews Database Without The API

The strategy, cheapest surface first:

1. **Product header from static HTML (Cheerio, no browser).** The server-rendered product page contains the business name (`h1#prodTitle1`), MouthShut Score % (`.recommendation`), average rating (`.product-rating .avg-star`), vote count (`[id*="liAllReviews"]`), the category breadcrumb (`p.breadcrumb`) and an `application/ld+json` `Product` block with `aggregateRating` (used as fallback).
2. **Internal reviews endpoint instead of paginating HTML pages.** The product page embeds `var query_string = 'cname=<name>&cid=<id>&forcount=<total>'`, the exact query string the site's own frontend uses to lazy-load reviews from `GET https://www.mouthshut.com/Review/rar_reviews.aspx`. The actor calls that endpoint directly (`...&page=N`) and parses the `.row.review-article` rows — same data as the UI, one light request per 20 reviews. (`cname`/`cid` fall back to being derived from the product URL slug `<cname>-reviews-<cid>`.)
3. **Per-review rating from star icons.** Each row renders `i.icon-rating.rated-star` × N (= the 1–5 rating); the date comes from `[id*="lblDateTime"]`; Pros/Cons are split out of `.rev-main-content` on the inline `Pros:`/`Cons` markers reviewers write.
4. **Search URLs → products → reviews.** A search listing (`/search/prodsrch.aspx?data=<term>`) renders its rows through `GET /search/prodsrch_loadmore_ajax.aspx?data=<term>&currentpage=N`. The actor calls that same endpoint directly, takes the `/product-reviews/<slug>-reviews-<id>` links (variants and category links are skipped), stops at `maxProductsPerSearch`, and feeds them into the product flow above.
5. **No Playwright.** Nothing on these pages requires JS execution — all fields are present in raw served HTML, so a CheerioCrawler is faster and cheaper.

**Anti-bot.** Mouthshut sits behind **Cloudflare (managed challenge)**; datacenter IPs with a bad reputation get a `403 / Just a moment...` page even for plain `curl`. If a run logs a Cloudflare-challenge error, re-run with the **Apify proxy enabled** (residential group recommended at scale). The actor is polite by default: concurrency 10, ~20 reviews per request, capped pages (max 25 listing pages / 500 reviews per product), 3 retries, 60 s timeouts.

### Input Parameters

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `productUrls` | array of strings | No (prefilled) | `https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914` | Mouthshut `product-reviews` page URLs. |
| `searchUrls` | array of strings | No | `https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0` | Discovery pages; the products they list are scraped automatically. |
| `maxProductsPerSearch` | integer | No | `10` | Products taken from each search URL (max 200). A cap, not a guarantee — title/category landing pages list only their own products. |
| `maxReviewsPerProduct` | integer | No | `50` | Max reviews per product (max 500). Free runs are capped at 10 reviews. |
| `maxRequestsPerCrawl` | integer | No | `100` | Request cap. Each product costs 1 request plus ~1 per 20 reviews. |
| `proxy` | object (proxy) | No | `useApifyProxy: false` | Standard Apify proxy picker — enable if you hit Cloudflare challenges. |

At least one of `productUrls` / `searchUrls` must be non-empty. A URL that is on `mouthshut.com` but is not a review page (search listing, category page, …) is read as a discovery page, so pasting it into `productUrls` works too. Any non-`prodsrch` landing page is read from its visible links only — hidden menus and sidebar widgets are skipped, so a books page yields books, not the browse mega-menu.

### Output Fields

The **reviews** dataset (**23 fields**; the default `overview` view shows Product, Review title, Rating, Date, Author and Review link):

| Field | Type | Description |
|---|---|---|
| `recordType` | string / null | Always `review` in this dataset. |
| `productName` | string / null | Name of the reviewed business or product. |
| `productUrl` | string / null | Canonical Mouthshut product-reviews page. |
| `productCategory` | string / null | Top-level Mouthshut category. |
| `reviewUrl` | string / null | Permalink of the individual review. |
| `reviewSlug` | string / null | URL slug of the review. |
| `reviewId` | string / null | Internal Mouthshut review identifier. |
| `title` | string / null | Headline of the review. |
| `rating` | integer / null | Star rating (1–5). |
| `date` | string / null | Publication date as shown on Mouthshut. |
| `channel` | string / null | Submission channel, e.g. `Mobile` or `Android App`. |
| `author` | string / null | Reviewer's Mouthshut username. |
| `authorUrl` | string / null | Link to the reviewer's public profile. |
| `authorLocation` | string / null | Location on the reviewer snippet. |
| `authorReviewsCount` | integer / null | How many reviews the author has written. |
| `verifiedMember` | boolean / null | Whether the reviewer is a MouthShut Verified Member. |
| `verifiedReview` | boolean / null | Whether Mouthshut verified the review's genuineness. |
| `brandResponded` | boolean / null | Whether the brand responded to the review. |
| `body` | string / null | Full review text without the Pros/Cons sections. |
| `pros` | string / null | Pros section, when the reviewer wrote one. |
| `cons` | string / null | Cons section, when the reviewer wrote one. |
| `views` | integer / null | View count shown on the review. |
| `commentsCount` | integer / null | Comment count shown on the review. |

The **products** dataset holds one summary row per product (name, category, MouthShut Score %, average rating, votes, rating distribution of the scraped sample, `foundThroughSearch`).

### Example Input And Output

**Input**

```json
{
  "productUrls": ["https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"],
  "searchUrls": ["https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"],
  "maxProductsPerSearch": 10,
  "maxReviewsPerProduct": 50,
  "proxy": { "useApifyProxy": true }
}
```

**Output (one reviews-dataset row)**

```json
{
  "recordType": "review",
  "productName": "Swiggy",
  "productUrl": "https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914",
  "productCategory": "Ecommerce and Online Business",
  "reviewUrl": "https://www.mouthshut.com/review/swiggy-review-xxxxxxxxxxxx",
  "reviewSlug": "swiggy-review-xxxxxxxxxxxx",
  "reviewId": "xxxxxxxxxxxx",
  "title": "Fast delivery, good offers",
  "rating": 5,
  "date": "Jul 30, 2026 10:51 AM",
  "channel": "Mobile",
  "author": "example_user",
  "authorUrl": "https://www.mouthshut.com/member/example_user",
  "authorLocation": "Mumbai India",
  "authorReviewsCount": 42,
  "verifiedMember": true,
  "verifiedReview": true,
  "brandResponded": false,
  "body": "Ordered dinner and it arrived warm and on time...",
  "pros": "Fast delivery, good packaging",
  "cons": "Delivery fee",
  "views": 1234,
  "commentsCount": 3
}
```

### Integrations & Automation

Every Apify actor is reachable through the **Apify API**, and this one plugs into **webhooks**, **Zapier** and **Make** so reviews can flow into a Google Sheet, Airtable base, BI dashboard or a sentiment-analysis pipeline. For reputation monitoring, run it on a **schedule** — a daily or weekly scrape of your product URLs is enough to catch new reviews and rating changes, and recurring runs also improve the actor's Store recommendation signals.

### Related Actors

- [trustpilot-scraper-ppe](https://apify.com/memo23/trustpilot-scraper-ppe) — the largest consumer-review scraper; pairs global Trustpilot reviews with India-specific Mouthshut data.
- [ratemds-scraper](https://apify.com/ahmed_jasarevic/ratemds-scraper) — consumer reviews for healthcare providers.
- [resellerratings-scraper](https://apify.com/ahmed_jasarevic/resellerratings-scraper) — merchant/retailer consumer reviews.
- [hellopeter-scraper](https://apify.com/ahmed_jasarevic/hellopeter-scraper) — consumer reviews from a major regional review platform.
- [brownbook-scraper](https://apify.com/ahmed_jasarevic/brownbook-scraper) — business/review directory listings.

### FAQ

#### Is there an official Mouthshut API?

Mouthshut does not publish a public API. This actor reads the site's server-rendered HTML and the same internal AJAX endpoints its own frontend calls, so you get structured reviews and ratings without an API key or a browser.

#### What are the alternatives to this actor / this data source?

For review data you can combine this with Trustpilot and Google Reviews scrapers. Mouthshut is India's largest consumer review platform, so it is the natural source for India-specific brand sentiment and complements global review sources rather than duplicating them.

#### How do I monitor my brand's reputation in India?

Add your product URLs (or a Mouthshut search URL) and schedule the actor daily. Each run returns the MouthShut Score, average rating, vote count and every new review with its Pros/Cons, so you can track sentiment and rating changes over time.

#### Can I get reviews for a whole category without listing every product?

Yes — pass a Mouthshut **search URL** (`/search/prodsrch.aspx?data=<term>`). The actor paginates the search results, collects up to `maxProductsPerSearch` products and scrapes their reviews in the same run.

#### Why is `commentsCount` sometimes null?

Comment and like counts on individual reviews load via AJAX after page render and are not exposed server-side, so they are captured only when present in the served HTML.

#### Do I need a proxy?

Mouthshut is behind Cloudflare. Small runs often succeed without a proxy; for scale or if you see a `Just a moment...` challenge, enable the Apify proxy (residential recommended).

### SEO Keywords

mouthshut, mouthshut reviews, mouthshut scraper, mouthshut api, product reviews india, india market research, brand reputation monitoring, product feedback analysis, d2c brand tracking, review scraper, sentiment analysis data, consumer reviews india, trustpilot scraper, mouthshut score, verified reviews

### For AI Agents & LLM Apps

Purpose: return one structured review row per Mouthshut.com review (plus a product summary row), for given product or search URLs.

Minimal working input:

```json
{ "productUrls": ["https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"], "maxReviewsPerProduct": 50 }
```

Variant (category discovery via search URL):

```json
{ "searchUrls": ["https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"], "maxProductsPerSearch": 10 }
```

Output fields (reviews dataset): `recordType, productName, productUrl, productCategory, reviewUrl, reviewSlug, reviewId, title, rating, date, channel, author, authorUrl, authorLocation, authorReviewsCount, verifiedMember, verifiedReview, brandResponded, body, pros, cons, views, commentsCount`. A second **products** dataset holds the per-product summary row.

Behaviors an agent should know:

- At least one of `productUrls` / `searchUrls` must be non-empty. `recordType` distinguishes `review` rows; the products dataset rows are `product`.
- If `maxReviewsPerProduct` is left unset it defaults to **50**; free-plan runs are capped at **10 reviews**.
- A non-review Mouthshut URL passed in `productUrls` is treated as a **discovery** page, not an error.
- `maxProductsPerSearch` is a cap, not a guarantee — title/category landing pages list only their own products (often 20) and are not paginated.
- `views`/`commentsCount` may be `null` when not present in served HTML; `pros`/`cons` are `null` when the reviewer wrote none.

Billing: pay-per-event — **$0.003 per review** ($3.00 / 1,000) and **$0.0015 per product summary** ($1.50 / 1,000), plus a $0.00005 actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Mouthshut**. It accesses only publicly available Mouthshut.com pages and the site's own internal AJAX endpoints; it does not log in, bypass authentication, or solve CAPTCHAs on anyone's behalf. Users are responsible for ensuring their use complies with Mouthshut's Terms of Service and with applicable data-protection law, including India's Digital Personal Data Protection Act and, where relevant, GDPR/CCPA. Output contains reviewer usernames and locations (personal data) and must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `productUrls` (type: `array`):

Mouthshut product/business review page URLs, e.g. https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914

## `searchUrls` (type: `array`):

Mouthshut search/discovery page URLs. Each one is opened, the product links it lists are collected (up to 'Max products per search') and their reviews are scraped. Use the URL from the browser address bar after searching on mouthshut.com, e.g. https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy\&type=\&p=0

## `maxProductsPerSearch` (type: `integer`):

How many products to discover from each search URL before moving on (default 10, max 200). Raise 'Max Requests per Crawl' accordingly, each product costs 1 request plus ~1 request per 20 reviews.

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

Maximum number of individual reviews to scrape per product (default 50, max 500). Free users are capped at 10 reviews per run.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of requests that can be made by this crawler.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"
  ],
  "searchUrls": [
    "https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"
  ],
  "maxProductsPerSearch": 10,
  "maxReviewsPerProduct": 50,
  "maxRequestsPerCrawl": 100,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `products` (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 = {
    "productUrls": [
        "https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"
    ],
    "searchUrls": [
        "https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/mouthshut-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 = {
    "productUrls": ["https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"],
    "searchUrls": ["https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/mouthshut-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 '{
  "productUrls": [
    "https://www.mouthshut.com/product-reviews/swiggy-reviews-925740914"
  ],
  "searchUrls": [
    "https://www.mouthshut.com/search/prodsrch.aspx?data=swiggy&type=&p=0"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/mouthshut-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/mouthshut-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/az28KfooBehol1vnZ/builds/MbFoqixVD62vlhEOg/openapi.json