# Shopee Shop Reviews & Ratings Scraper (`dami_studio/shopee-shop-reviews-scraper`) Actor

A Shopee shop id works on one of eight storefronts and nowhere else. The market comes from your URL, never a default. Star rating, text, buyer handle, date, photos and video, product and variation, three sub-scores, seller replies, plus the rating breakdown. $3.79 per 1,000.

- **URL**: https://apify.com/dami\_studio/shopee-shop-reviews-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 1 total users, 0 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/actors/running/actors-in-store.md#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

## Shopee Shop Reviews & Ratings Scraper

There are eight Shopee storefronts, and a shop id works on exactly one of them. Send a shopee.sg shop id to shopee.co.id and Shopee answers HTTP 200 with an empty list, which reads exactly like a shop nobody has reviewed. So the market is taken from the URL you hand over, never guessed at.

Reviews come back one row each: the star rating, the text, the buyer's handle, the date, any photos or video they attached, which product and variation it was left for, the three sub-scores, and the seller's reply where there is one. There's also one summary row per shop carrying its own rating breakdown.

All eight Shopee markets work. You don't need a Shopee account, a cookie, an API key or a proxy.

### What you get

One row per review:

| Field | |
|---|---|
| `rating_star` | 1-5 |
| `comment` | the review text, with `has_comment` so you can filter out stars-only ratings |
| `detailed_rating` | `product_quality`, `seller_service`, `delivery_service` |
| `author_username` | buyer handle, plus `author_masked` when Shopee returns it partly starred out |
| `review_date` | ISO 8601, plus the raw `ctime` |
| `images`, `image_count`, `video_count` | buyer-uploaded media |
| `itemid`, `product_name`, `model_name`, `product_url` | the product and variation the review is for |
| `seller_reply`, `seller_reply_date` | the shop's response, where one exists |
| `cmtid`, `orderid`, `like_count` | review and order ids, helpful votes |
| `shopid`, `shop_username`, `shop_name`, `country`, `host` | where it came from |

Plus one `type: "shop"` row per shop: average star rating, good/normal/bad counts, total ratings, item count, follower count, seller response rate and response time.

#### How often each field is actually filled

Measured across 963 real rows, so you can plan around it instead of finding out later:

| Field | Present on |
|---|---|
| `itemid`, `rating_star`, `product_name`, `review_date` | 100% |
| `author_username` | 99% |
| `model_name` (variation) | 80% |
| `detailed_rating` sub-scores | 76% |
| non-empty `comment` text | 44% |
| at least one photo | 32% |
| at least one video | 19% |
| seller reply | 0.3% |

Most Shopee ratings are stars and nothing else. If you only want the ones carrying an actual comment, set `onlyWithText` and you'll get that 44%.

### Markets

`shopee.sg` · `shopee.com.my` · `shopee.co.id` · `shopee.vn` · `shopee.ph` · `shopee.co.th` · `shopee.tw` · `shopee.com.br`

Always paste the full URL including the market host. Shop ids are scoped per market, so the same id means nothing on a different one, and Shopee answers a cross-market lookup with an empty list rather than an error. The actor checks the shop exists on the host you gave before collecting anything, so a wrong-market URL gets you a clear message instead of a confusingly empty run.

### Input

```json
{
  "startUrls": ["https://shopee.sg/shop/1103391312"],
  "maxReviewsPerShop": 100,
  "starRatings": ["5", "4", "3", "2", "1"],
  "onlyWithText": false,
  "onlyWithMedia": false,
  "includeShopSummary": true
}
```

Shop URLs work as either `https://shopee.sg/shop/1103391312` or `https://shopee.sg/baseus.sg`.

### Limits worth knowing before you start

**Shopee serves about 1,000 reviews per star rating per shop**, roughly 5,000 in total, newest first. That ceiling is Shopee's own pagination, not a limit this actor imposes. Every run reports what it collected against the shop's declared rating total, and says so plainly when it hit the ceiling. On a big shop that means you're sampling, not archiving: 100 reviews out of a shop with 74,025 ratings is 0.14% of them, and the `coverage_note` on every row tells you so.

**Star buckets are swept evenly.** Shopee paginates each rating separately. Cap a run and the budget spreads across the ratings you picked rather than filling from five stars down, so you get a representative spread instead of nothing but praise.

**Product URLs return a subset.** You can pass a product URL (`…-i.<shop>.<item>` or `/product/<shop>/<item>`) and get the reviews for that product. Know what that is, though. Shopee closed its per-item review endpoint, so the open route is the shop-wide one, and what you get for a product URL is the slice of that sweep belonging to your product. On a busy shop that's a minority of its real review history. Every row says so in `coverage_note`. Scrape the shop if you want completeness.

### Billing

Pay per event. You're charged for the `review` event and nothing else: **$0.00379 per review on the free plan, dropping to $0.00279 on Gold and above**. That's $3.79 and $2.79 per 1,000. There's also a $0.005 actor-start charge per GB of run memory.

What you are not charged for:

- **Shop summary rows.** The rating breakdown, follower count and response rate are free.
- **Notices, skipped URLs, coverage warnings and the run summary.** These never enter the dataset at all. They go to the run log, the status message, and the key-value store under `NOTICES_AND_RUN_STATUS`.
- **A run that returns no reviews.** A wrong-market URL or an unreachable shop costs you the start fee and nothing else.

If you set a maximum total charge on the run, the actor stops cleanly when it gets there rather than overrunning it.

### Speed

The default 100-review run is 5 requests and finishes in about two seconds. A full 5,000-review sweep is 50 requests, and the pacing between them is most of the wall time. Shopee's `robots.txt` asks for a one-second crawl delay; the actor paces itself with `requestDelayMs`, which you can raise if you're sweeping many shops in one run.

# Actor input Schema

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

Shop URLs (https://shopee.sg/shop/123456 or https://shopee.sg/shopusername) return that shop's reviews. Product URLs (…-i.<shop>.<item> or /product/<shop>/<item>) return the reviews from the shop-wide sweep that belong to that product — Shopee publishes no per-product review feed, so that is a subset, not the product's full history. Always include the market host: shop ids are scoped per market, and an id from the wrong market returns an empty result.

## `maxReviewsPerShop` (type: `integer`):

Upper bound on reviews collected per shop. Shopee itself serves at most about 1,000 reviews per star rating (roughly 5,000 per shop), so values above that cannot be met by any client.

## `starRatings` (type: `array`):

Which star buckets to sweep. Shopee paginates each star rating separately, so narrowing this makes a run faster. Whatever you pick, a capped run spreads its budget evenly across them rather than filling up from five stars down.

## `onlyWithText` (type: `boolean`):

Many Shopee ratings are stars only. Turn this on to drop those and keep reviews with an actual comment.

## `onlyWithMedia` (type: `boolean`):

Keep only reviews that include buyer photos or video.

## `includeShopSummary` (type: `boolean`):

Adds one row per shop with its average star rating, good/normal/bad counts, follower count, item count and seller response rate.

## `requestDelayMs` (type: `integer`):

Shopee's robots.txt asks for a one-second crawl delay. This actor's sweeps are small, but raise this if you are scraping many shops in one run.

## Actor input object example

```json
{
  "startUrls": [
    "https://shopee.sg/shop/1103391312"
  ],
  "maxReviewsPerShop": 100,
  "starRatings": [
    "5",
    "4",
    "3",
    "2",
    "1"
  ],
  "onlyWithText": false,
  "onlyWithMedia": false,
  "includeShopSummary": true,
  "requestDelayMs": 250
}
```

# Actor output Schema

## `results` (type: `string`):

Review rows and shop summary rows are stored in the default dataset (one row per item).

## `runStatus` (type: `string`):

Coverage notes, skipped URLs and the per-shop run summary are stored free of charge in the default key-value store under NOTICES\_AND\_RUN\_STATUS.

# 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": [
        "https://shopee.sg/shop/1103391312"
    ],
    "maxReviewsPerShop": 100,
    "starRatings": [
        "5",
        "4",
        "3",
        "2",
        "1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/shopee-shop-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": ["https://shopee.sg/shop/1103391312"],
    "maxReviewsPerShop": 100,
    "starRatings": [
        "5",
        "4",
        "3",
        "2",
        "1",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/shopee-shop-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": [
    "https://shopee.sg/shop/1103391312"
  ],
  "maxReviewsPerShop": 100,
  "starRatings": [
    "5",
    "4",
    "3",
    "2",
    "1"
  ]
}' |
apify call dami_studio/shopee-shop-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/shopee-shop-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/LYBO0uLMaYygTf6GE/builds/rHSsFZptq0isO7if8/openapi.json