# Blibli Store Review & Sentiment Analyzer (`zucchini_gopher_m2v/blibli-store-review-analyzer`) Actor

Collect buyer reviews from any Blibli store or product - yours or a competitor's - as clean text for AI sentiment analysis. Captures nearly all negative reviews, plus the rating histogram and Blibli's own topic breakdown. No login needed.

- **URL**: https://apify.com/zucchini\_gopher\_m2v/blibli-store-review-analyzer.md
- **Developed by:** [Faisal Ahdan naufal](https://apify.com/zucchini_gopher_m2v) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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.

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

## Blibli Store Review & Sentiment Analyzer

Collect buyer reviews from any [Blibli](https://www.blibli.com) store —
your own or a competitor's — as clean text ready to feed straight into an
LLM for sentiment analysis, complaint clustering, or product-strength
mining.

Point it at a store and it returns the written reviews plus a summary of
the store's **entire** review base: rating histogram, negative share, and
Blibli's own topic breakdown (quality, price, shipping, packaging, service,
authenticity).

No login, no API key. HTTP-only — no browser.

### What makes it useful

**It captures the complaints.** Blibli only exposes ~600 reviews per query,
and these stores run ~98% positive — so a naive scrape returns a wall of
5-star praise. This actor sweeps each star rating as its own query, which
on the store used for testing returned **292 of the 294 one-star reviews
that exist**, out of a base of 68,842. Negative feedback is the scarce,
valuable part, and it is what you actually get.

**It only returns reviews with words.** About **half** of Blibli's reviews
are star-only ratings with no text — useless for sentiment work. Those are
filtered out server-side, so your run (and your bill) is spent on reviews
an AI can actually read.

**The summary row alone may answer the question.** One cheap record per
store carries the topic counts across the whole review base — "what do
customers keep bringing up" without spending a single AI token.

### Input

```json
{
  "storeUrls": [
    "https://www.blibli.com/merchant/colgate-palmolive-indonesia-flagship-store/COP-60023",
    "COP-60023",
    "https://www.blibli.com/p/sandisk-ultra-microsdxc-64gb/ps--BLL-70058-00122"
  ],
  "coverage": "deep",
  "sortBy": "LATEST",
  "onlyWithText": true
}
```

`storeUrls` accepts a store URL, a bare store code (`COP-60023`), a product
URL, a bare product SKU, or `brand:<name>` — mixed freely, so your store
and your competitors' go in one run.

| Field | Description |
| --- | --- |
| `coverage` | `standard` (one sweep, ~600), **`deep`** (per-rating sweeps — captures nearly all negatives), `maximum` (adds per-topic sweeps) |
| `sortBy` | `LATEST`, `POPULAR`, `OLDEST`, `HIGHEST`, `LOWEST` |
| `onlyWithText` | Skip star-only ratings. On by default |
| `onlyWithMedia` | Only reviews with buyer photos/videos |
| `minRating` | Keep only reviews at or above N stars (0 = off) |
| `maxReviewsPerTarget` | Cap per store/product (0 = no limit) |
| `includeSummary` | Emit the store summary row. On by default |
| `productBreakdown` | Also sweep each product separately — each has its own ~600-review window |
| `maxProductsPerStore` | Cap for `productBreakdown` |
| `proxyConfiguration` | Apify Residential + country `ID` recommended |

### Output

Two record shapes, discriminated by `recordType`.

**`REVIEW`** — one per review, Blibli's own fields passed through verbatim
plus flattened fields for AI pipelines:

```json
{
  "recordType": "REVIEW",
  "id": "74f5b34c-6db2-41c0-b22e-bcb4de44ab56",
  "rating": 2,
  "reviewText": "Gak dapet kantongan tas IU nya",
  "ratingPolarity": "negative",
  "reviewLength": 32,
  "hasText": true,
  "verifiedBuyer": true,
  "productSku": "COP-60023-01124",
  "merchantName": "Colgate Palmolive Indonesia Flagship Store",
  "createdAtIso": "2026-07-27T14:39:13Z",
  "imageCount": 0,
  "videoCount": 0,
  "matchedTopic": null,
  "matchedRatingFilter": "1"
}
```

**`STORE_SUMMARY`** — one per store, describing the *entire* review base:

```json
{
  "recordType": "STORE_SUMMARY",
  "merchantName": "Colgate Palmolive Indonesia Flagship Store",
  "totalReviews": 68842,
  "commentCount": 32843,
  "averageRating": 4.9,
  "negativeSharePercent": 0.72,
  "positiveSharePercent": 98.48,
  "ratingCounts": { "1": 294, "2": 203, "3": 549, "4": 2817, "5": 64979 },
  "topicCounts": {
    "QUALITY": 1181, "PRICE": 1006, "SHIPMENT": 935,
    "PACKAGING": 627, "SERVICE": 220, "ORIGINALITY": 213, "GENERIC": 776
  }
}
```

`ratingPolarity` is derived directly from the star rating (`negative` for
1–2, `neutral` 3, `positive` 4–5). It is **not** natural-language sentiment
analysis — it is a cheap pre-filter so you can spend LLM tokens only on the
reviews that matter.

`matchedTopic` is set when a review was surfaced by a topic sweep, meaning
Blibli itself classifies it under that topic.

### Feeding it to an AI

Filter to `ratingPolarity == "negative"` and `hasText == true`, then group
by `productSku`, and pass `reviewText` to your model. The `topicCounts` in
the summary row tell you which themes to expect before you start.

### Known limits

- **~600 reviews per query slice.** A store with 68k reviews cannot be
  extracted in full. `deep` and `maximum` coverage widen the sample, and
  `productBreakdown` opens a separate window per product — but the summary
  row is what describes the complete base.
- **Reviews are in Indonesian.** Use a multilingual sentiment model.
- **Reviewer names arrive masked** by Blibli (`M***a`). This actor does not
  attempt to unmask them, and returns only reviews Blibli shows publicly.
- `brand:<name>` targets are accepted but returned no results for every
  brand tried during recon.
- Roughly half of all reviews have no text; with `onlyWithText` on (the
  default) those never reach your dataset.

### Reliability

Blibli sits behind **Cloudflare**. The actor clears it HTTP-only with TLS
impersonation plus the `Referer` header Cloudflare's rule requires — no
browser, no CAPTCHA solver. On a block it retries with exponential backoff
while rotating both the TLS fingerprint and, when a proxy is configured,
the egress IP.

A failing target never sinks the run: it emits an `ERROR` record with
`_error` and `_errorDetail` and the remaining targets continue.

See [CRAWLING\_METHOD.md](CRAWLING_METHOD.md) for the full endpoint
analysis, including the decoy endpoint that reports zero reviews for
products that have hundreds.

# Actor input Schema

## `storeUrls` (type: `array`):

What to pull reviews for. Accepts a store URL (https://www.blibli.com/merchant/<name>/COP-60023), a bare store code (COP-60023), a product URL (https://www.blibli.com/p/<name>/ps--COP-60023-00933), a bare product SKU, or 'brand:<name>'. Mix freely - your own store and competitors' in one run.

## `coverage` (type: `string`):

Blibli only exposes about 600 reviews per query. 'standard' does one sweep (fastest). 'deep' also sweeps each star rating separately, which usually captures nearly ALL 1- and 2-star reviews even on a store with tens of thousands - the setting to use for complaint analysis. 'maximum' additionally sweeps each review topic.

## `sortBy` (type: `string`):

Order Blibli returns reviews in. 'LATEST' is best for tracking sentiment over time; 'POPULAR' surfaces the reviews other shoppers found most helpful.

## `maxReviewsPerTarget` (type: `integer`):

Stop after this many reviews per store/product. 0 means no limit - sweep until the coverage plan is exhausted.

## `minRating` (type: `integer`):

Keep only reviews at or above this rating. 0 disables the filter. Set to 0 and use the ratingPolarity field to isolate complaints instead.

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

Skip star-only ratings that carry no words. About half of Blibli's reviews have no text at all, and they are useless for sentiment analysis - this is filtered server-side, so pagination is spent entirely on reviews you can actually feed to an AI. Turn off only if you want the raw rating stream.

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

Restrict to reviews that include buyer photos or videos - useful for spotting product defects that shoppers photographed.

## `includeSummary` (type: `boolean`):

Emit one STORE\_SUMMARY record per target with the full rating histogram, average rating, negative/positive share, and Blibli's own topic counts (quality, price, shipping, packaging, service, authenticity) across the store's ENTIRE review base - not just the sampled reviews. Cheap and the single most useful row for sentiment analysis.

## `productBreakdown` (type: `boolean`):

Expand a store into its individual products and sweep each one's reviews too. Each product has its own ~600-review window, so this greatly deepens coverage on large stores - at the cost of one request set per product.

## `maxProductsPerStore` (type: `integer`):

Only used when 'Also sweep each product separately' is on. Caps how many of the store's products get their own review sweep.

## `proxyConfiguration` (type: `object`):

Blibli is behind Cloudflare. Apify Residential proxy with country 'ID' is recommended for long runs; short runs usually succeed without a proxy.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.blibli.com/merchant/colgate-palmolive-indonesia-flagship-store/COP-60023"
  ],
  "coverage": "deep",
  "sortBy": "LATEST",
  "maxReviewsPerTarget": 0,
  "minRating": 0,
  "onlyWithText": true,
  "onlyWithMedia": false,
  "includeSummary": true,
  "productBreakdown": false,
  "maxProductsPerStore": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All review and store-summary records from this run.

# 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 = {
    "storeUrls": [
        "https://www.blibli.com/merchant/colgate-palmolive-indonesia-flagship-store/COP-60023"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zucchini_gopher_m2v/blibli-store-review-analyzer").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 = { "storeUrls": ["https://www.blibli.com/merchant/colgate-palmolive-indonesia-flagship-store/COP-60023"] }

# Run the Actor and wait for it to finish
run = client.actor("zucchini_gopher_m2v/blibli-store-review-analyzer").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 '{
  "storeUrls": [
    "https://www.blibli.com/merchant/colgate-palmolive-indonesia-flagship-store/COP-60023"
  ]
}' |
apify call zucchini_gopher_m2v/blibli-store-review-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zucchini_gopher_m2v/blibli-store-review-analyzer"
        }
    }
}

```

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/FJwhzjCYvLBGS767q/builds/fP9K839S5qlRgSzcY/openapi.json