# Tokopedia Products, Sellers & Reviews Monitor (`automation-lab/tokopedia-products-sellers-monitor`) Actor

Extract public Tokopedia product, category and merchant catalog data with prices, ratings, review totals, seller details, availability and scheduled change monitoring.

- **URL**: https://apify.com/automation-lab/tokopedia-products-sellers-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 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

## Tokopedia Products, Sellers & Reviews Monitor

Extract public Tokopedia product and merchant data for price tracking, catalog research, seller analysis, and recurring marketplace monitoring.

The Actor accepts real Tokopedia product, category, and merchant URLs. It returns one normalized product observation per dataset row with current price, ratings, review totals, sales signals, seller details, stock or availability when exposed, and a timestamp.

No Tokopedia login or API key is required.

### What can the Tokopedia monitor do?

- Extract products from public Tokopedia category pages.
- Extract a merchant's public product catalog.
- Inspect an individual product page in more detail.
- Capture current and original prices in Indonesian rupiah.
- Capture ratings, review totals, and per-star rating counts where available.
- Include seller name, location, official-store status, rating, and review totals.
- Record public sales-signal text such as `100+ terjual`.
- Normalize stock and availability when the source page exposes them.
- Compare selected fields with a previous observation in persistent Task storage.
- Export records as JSON, CSV, Excel, XML, RSS, or through the Apify API.

The implementation reads Tokopedia's public server-rendered data using a Chrome TLS fingerprint. It does not automate login, checkout, messages, or Seller Center.

### Who is it for?

**Marketplace analysts** can compare assortment, prices, ratings, and seller coverage.

**Brands and distributors** can observe public listings for their products and competing offers.

**Merchants** can track a competitor's catalog and identify newly changed public product signals.

**Data teams** can schedule collection and feed normalized product rows into a warehouse or dashboard.

**Developers and AI agents** can call one Actor rather than maintain Tokopedia page parsing and output normalization.

### Supported Tokopedia URLs

| URL type | Example shape | Output |
| --- | --- | --- |
| Category | `https://www.tokopedia.com/p/handphone-tablet/handphone` | Product cards with price, seller, rating, reviews, image, and sales signals |
| Merchant | `https://www.tokopedia.com/{shop}` | Shop catalog products plus seller context |
| Merchant catalog | `https://www.tokopedia.com/{shop}/product` | Same merchant-catalog workflow |
| Product | `https://www.tokopedia.com/{shop}/{product-slug}` | One detailed product observation and rating summary |

Tokopedia search-result URLs are not supported. That surface uses a separately protected delivery path. Use a public category, merchant catalog, or product URL instead.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `productId` | Tokopedia product ID |
| `url` | Public product URL |
| `name` | Product title |
| `price` | Numeric current price in IDR |
| `priceFormatted` | Price exactly as displayed |
| `originalPrice` | Visible pre-discount price, if present |
| `rating` | Product rating, if exposed on the source page |
| `reviewCount` | Visible product review or rating count |
| `soldText` | Public sales signal, for example `100+ terjual` |
| `imageUrl` | Main public product image |
| `category` | Category name, path, or ID available on the page |
| `availability` | `available`, `unavailable`, or `unknown` |
| `stock` | Numeric stock when exposed on a detail page |
| `seller` | Seller ID, name, URL, location, official status, rating, and review total |
| `reviewSummary` | Detail-page score, total ratings, and per-star counts |
| `sourceType` | `product`, `category`, or `shop` |
| `sourceUrl` | Input page that produced the row |
| `observedAt` | UTC observation timestamp |
| `changeStatus` | `new`, `changed`, or `unchanged` when monitoring is enabled |
| `changedFields` | Snapshot fields that changed since the previous stored observation |

Fields can be `null` when Tokopedia does not expose the value on that page type.

### How to get started

1. Open the Actor input page.
2. Add one or more public Tokopedia category, shop, or product URLs.
3. Choose a maximum number of products.
4. Optionally set price or rating filters.
5. Enable **Compare with previous run** for a recurring monitoring Task.
6. Click **Start**.
7. Open the **Tokopedia products** dataset view.
8. Export the data or connect it to your workflow.

A useful first run is:

```json
{
  "startUrls": [
    { "url": "https://www.tokopedia.com/p/handphone-tablet/handphone" }
  ],
  "maxItems": 20
}
```

### Input parameters

#### `startUrls`

Required list of public Tokopedia URLs. Non-Tokopedia domains are rejected. URLs are normalized to HTTPS and fragments are removed.

#### `maxItems`

Maximum accepted rows across all input URLs. Range: 1–500. The default is 100.

#### `minPrice` and `maxPrice`

Optional inclusive price filters in IDR. A product without a visible numeric price is not rejected solely because its price is `null`.

#### `minRating`

Optional minimum rating from 0 to 5. Products without a visible rating count as 0 for this filter.

#### `monitorChanges`

When enabled, the Actor stores a compact snapshot keyed by product URL and compares it on the next run that uses the same key-value store.

For reliable recurring comparisons, create an Apify Task, preserve its storage between runs, and schedule that Task.

#### `proxyConfiguration`

Optional Apify proxy settings. Direct HTTP with Chrome TLS impersonation is the tested default. A proxy is not automatically required.

### Example output

A category or catalog row looks like this:

```json
{
  "type": "product",
  "productId": "102844165567",
  "url": "https://www.tokopedia.com/ceriaponselos/example-product",
  "name": "Example smartphone 8/256 GB",
  "price": 3688000,
  "priceFormatted": "Rp3.688.000",
  "originalPrice": 3999000,
  "currency": "IDR",
  "rating": 4.9,
  "reviewCount": 120,
  "soldText": "100+ terjual",
  "availability": "available",
  "seller": {
    "id": "9230215",
    "name": "Example Official Shop",
    "url": "https://www.tokopedia.com/example-shop",
    "location": "Tangerang",
    "isOfficial": true,
    "rating": 5,
    "reviewCount": 1788
  },
  "sourceType": "shop",
  "observedAt": "2026-01-15T12:00:00.000Z"
}
```

The example is anonymized. Actual field availability depends on the input page.

### How change monitoring works

With `monitorChanges: true`, the Actor compares these fields:

- `price`
- `originalPrice`
- `availability`
- `stock`
- `rating`
- `reviewCount`
- `soldText`

The first observation is `new`. Later observations are `changed` or `unchanged`, and `changedFields` names the differences.

Snapshots are kept in the run's default key-value store. If storage is purged or replaced, the next observation is new again.

This Actor reports observations; it does not send alerts itself. Use Apify schedules, webhooks, Zapier, Make, Slack, email automation, or your own pipeline to notify on `changeStatus === "changed"`.

### How much does it cost to monitor Tokopedia products?

The Actor uses pay-per-event pricing:

- a **$0.00005 start fee** per run;
- one `item` event for each accepted product row;
- the BRONZE item rate is **$0.0008 per product**, with lower rates at higher pricing tiers.

At the BRONZE rate, excluding any optional proxy traffic:

| Accepted products | BRONZE charge calculation |
| ---: | ---: |
| 1 | $0.00005 start + 1 × $0.0008 item |
| 20 | $0.00005 start + 20 × $0.0008 item |
| 100 | $0.00005 start + 100 × $0.0008 item |
| 500 | $0.00005 start + 500 × $0.0008 item |

Filters are applied before saving and charging a product. Duplicate product IDs in the same run are not charged twice.

Apify platform compute and optional proxy usage may also apply according to your Apify plan. Check the live pricing panel for the tier assigned to your account.

### Scheduling a merchant catalog monitor

1. Save a Task with a merchant URL and `monitorChanges: true`.
2. Set `maxItems` to the catalog volume you need, up to 500.
3. Run it once to establish snapshots.
4. Schedule it hourly, daily, or weekly.
5. Keep Task storage instead of purging it.
6. Add a webhook for successful runs.
7. In your destination, keep rows where `changeStatus` is `changed` or `new`.

A catalog page currently exposes up to about 60 products in its server-rendered payload. The Actor does not claim complete pagination beyond the public payload returned for each URL.

### Export and integration ideas

- Export CSV for a one-time assortment or price comparison.
- Send JSON rows to BigQuery, Snowflake, PostgreSQL, or a data lake.
- Build a Looker Studio or Power BI dashboard around `observedAt` and `price`.
- Trigger a webhook when a scheduled run finishes.
- Use Make or Zapier to notify a channel about changed products.
- Compare sellers by location, official status, rating, and public sales signal.
- Feed product observations to an AI agent for summarization or anomaly review.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tokopedia-products-sellers-monitor/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.tokopedia.com/cellsius"}],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tokopedia-products-sellers-monitor').call({
  startUrls: [{ url: 'https://www.tokopedia.com/cellsius' }],
  maxItems: 20,
  monitorChanges: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/tokopedia-products-sellers-monitor").call(run_input={
    "startUrls": [{"url": "https://www.tokopedia.com/cellsius"}],
    "maxItems": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use the Actor through MCP

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/tokopedia-products-sellers-monitor"
```

#### Claude Desktop

Add this server to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tokopedia-products-sellers-monitor"
    }
  }
}
```

#### Cursor

Add the same `apify` HTTP server URL in **Cursor Settings → MCP**.

#### VS Code

Add the same `apify` HTTP server URL to your VS Code MCP servers configuration.

Example prompts:

- “Extract 20 products from this Tokopedia phone category and rank them by price.”
- “Collect the public Cellsius catalog and summarize seller and rating signals.”
- “Run my Tokopedia monitoring Task and show only products whose price changed.”

### Reliability and failure behavior

The Actor verifies HTTP status and the recognizable public Tokopedia data cache. A challenge page or unexpected page shape fails the run instead of silently returning an empty successful dataset.

Transient network errors can be retried by rerunning the Task. For repeated geographic delivery issues, enable an Apify proxy and keep one coherent session per run.

Invalid domains, malformed URLs, invalid numeric filters, and `minPrice > maxPrice` fail closed with a clear error.

A page with no public products produces a warning and no rows for that URL.

### Tips and limitations

- Use category, merchant, or product URLs rather than search-result URLs.
- Start with direct requests; enable a proxy only if needed.
- Keep limits small while designing a recurring workflow.
- Product detail pages expose richer review and stock fields than listing pages.
- Listing ratings and review counts can be absent even when a detail page has them.
- Tokopedia can change its page payload without notice.
- Prices and availability are observations at `observedAt`, not guarantees.
- This release reads the first public server-rendered catalog payload for each URL.
- Monitoring compares snapshots; it does not preserve a full historical table unless you retain datasets externally.
- The Actor does not scrape private accounts, Seller Center, checkout, chats, or personal order data.

### Legality and responsible use

Only collect public data you are authorized to use.

Review Tokopedia's terms and applicable laws for your use case. Avoid collecting unnecessary personal data, respect intellectual property, and choose a schedule that does not create excessive traffic.

Do not use the Actor for account access, purchases, spam, harassment, discriminatory profiling, or attempts to bypass access controls.

The user is responsible for the purpose, retention, and downstream use of exported data.

### Troubleshooting

#### Why did my search URL fail?

Tokopedia search-result URLs use a separately protected route and are intentionally unsupported. Supply a public category URL under `/p/`, a merchant URL, or a product URL.

#### Why is a rating or stock field null?

Tokopedia exposes different fields on category, shop, and product pages. Use a product detail URL for the richest product-specific rating and stock data.

#### Why is every product new again?

The comparison key-value store was probably purged or replaced. Run a saved Task with persistent storage and do not purge it between scheduled runs.

#### Why did the Actor report an unexpected page?

Tokopedia may have returned a challenge or changed its public payload. Retry once, then try an Apify proxy. Include the run ID and input URL when reporting a reproducible issue.

#### Does monitoring send alerts?

No. Connect successful runs to a webhook, Make, Zapier, Slack, email, or your own service and filter on `changeStatus`.

### FAQ

#### Does it require a Tokopedia account?

No. It reads supported public pages without login.

#### Does it support Tokopedia Indonesia?

Yes. The source is Tokopedia's public Indonesian marketplace, and prices are returned in IDR.

#### Is this an official Tokopedia API?

No. It is an independent Apify Actor that normalizes data exposed on public pages.

#### Can it extract customer review text?

This release extracts review totals and per-star rating counts on supported product detail pages. It does not claim individual review-text pagination.

#### Can I monitor several merchants?

Yes. Add several merchant URLs. The global `maxItems` limit applies across them in input order.

#### Can I request more than 500 products?

Not in one run of this release. Split the input across Tasks if you need separate public category or merchant observations.

### Related Automation Lab actors

For broader web monitoring workflows, consider:

- [Webpage Structured Data Monitor](https://apify.com/automation-lab/webpage-structured-data-monitor) for non-Tokopedia pages with structured metadata.
- [Website Uptime Checker](https://apify.com/automation-lab/website-uptime-checker) for endpoint availability rather than product data.

Use this Actor when the source is Tokopedia and you need normalized product, seller, price, rating, review, availability, and change records.

### Support

If a real supported URL fails, share the Apify run ID, the non-sensitive input, and the expected versus actual result. Do not post API tokens, private account details, or cookies.

# Actor input Schema

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

Public Tokopedia product, category (/p/...), shop, or shop /product URLs. Search result URLs are not supported because Tokopedia protects that surface separately.

## `maxItems` (type: `integer`):

Stop after this many accepted product records across all URLs.

## `minPrice` (type: `integer`):

Keep products at or above this price in Indonesian rupiah.

## `maxPrice` (type: `integer`):

Keep products at or below this price in Indonesian rupiah. Leave empty for no upper limit.

## `minRating` (type: `number`):

Keep products with at least this rating. Products without a visible rating count as 0.

## `monitorChanges` (type: `boolean`):

Add changeStatus and changedFields by comparing products with snapshots in the run's key-value store. Reuse the same storage in a scheduled Task to monitor changes.

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

Optional proxy. Direct Chrome-TLS HTTP is the working default; use an Apify proxy only when your run environment requires it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tokopedia.com/p/handphone-tablet/handphone"
    }
  ],
  "maxItems": 20,
  "minPrice": 0,
  "minRating": 0,
  "monitorChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Default dataset containing all accepted product observations.

## `monitorState` (type: `string`):

Key-value store snapshots used for change comparison when monitoring is enabled.

# 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.tokopedia.com/p/handphone-tablet/handphone"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tokopedia-products-sellers-monitor").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.tokopedia.com/p/handphone-tablet/handphone" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tokopedia-products-sellers-monitor").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.tokopedia.com/p/handphone-tablet/handphone"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/tokopedia-products-sellers-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/tokopedia-products-sellers-monitor"
        }
    }
}

```

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/21C4mcL5E1Yqs9WV1/builds/0aTOewpKqGvi9sQdw/openapi.json