# Lazada Product Scraper — Price Tracker, Stock & Sales API (`blueskyscraper/lazada-product-scraper`) Actor

Track Lazada prices, discounts, stock and sales on a schedule in Singapore, Malaysia, Thailand, the Philippines, Vietnam and Indonesia. Every run flags price drops, rises, restocks and new items vs the last run. Also scrapes products, search, shops and reviews. Export, API, MCP.

- **URL**: https://apify.com/blueskyscraper/lazada-product-scraper.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** E-commerce, Automation, AI
- **Features:** Limited permissions
- **Stats:** 12 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 product details

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

### What is Lazada Price Tracker?

**Lazada Price Tracker** watches **Lazada prices, discounts, stock and sales over time** on all six Lazada storefronts — **Indonesia, Malaysia, Singapore, Thailand, the Philippines and Vietnam**. Schedule it daily or hourly on your products, a search or a competitor's shop, and every run tells you what changed since the run before: 📉 price drops, 📈 price rises, 📦 sell-outs and restocks, 🆕 new listings and how many units sold in between.

It is also a full **Lazada scraper** and an unofficial **Lazada API**: product details with every variant's price and stock, search results, whole **shop catalogs** with 7- and 30-day sales, and ⭐ reviews with photos and seller replies. No login, no cookies, no official API key. Download the rows as JSON, CSV or Excel, or read them through the API, webhooks or an AI agent over MCP.

### 📈 How to monitor Lazada prices on a schedule

1. Put your product URLs, a keyword or a shop URL into the input.
2. Type any name into **📈 Watchlist name**, for example `my-competitors`.
3. Press **Save & Start**, then **Schedule** the Actor (daily or hourly) with the same input.

Every run compares itself with the previous run of the same watchlist. Each row gets:

| Field | Example | Meaning |
|---|---|---|
| `changeType` | `price-down` | `new`, `price-down`, `price-up`, `stock` or `unchanged` |
| `previousPrice` → `price` | `35` → `31.54` | price at the previous run and now |
| `priceChange`, `priceChangePercent` | `-3.46`, `-9.89` | |
| `previousStockStatus`, `stockChanged` | `out_of_stock`, `true` | sold out or back in stock |
| `soldDelta`, `soldLast7DaysDelta` | `42` | units sold since the previous run |
| `daysSincePrevious` | `1` | |

The run's status line sums it up — *"5 rows. Since the previous run: 1 price-down, 1 price-up, 1 stock, 1 new."* — and the **📈 Price & stock changes** tab of the dataset shows only the comparison columns. Filter on `changeType != "unchanged"` in a webhook, Make, n8n or Zapier step to get an alert only when something moved.

A monitoring run (a watchlist name or a previous dataset in the input) **always reads live data**: prices and stock are read at run time, never from a saved copy, so a change shows up in the run that follows it. Product rows of a monitoring run are therefore live rows and are priced as such (see the price table).

The comparison itself is **free**. The history lives in a named key-value store on your own Apify account (`lazada-watch-<name>`), so nothing is lost between runs and items that drop out of a search keep their last known price. For a one-off comparison you can instead pick an earlier dataset in **📈 Compare with a previous run dataset**.

### What data can Lazada Scraper extract?

#### 📦 Product details (one row per product URL)

| Field | Example | Notes |
|---|---|---|
| `title`, `brand` | `HADA LABO Hydrating Cleansing Oil 200ml`, `Hada Labo` | |
| `price` / `priceText` | `44.54` / `RM44.54` | current sale price, number and as printed |
| `originalPrice`, `discountPercent` | `65.5`, `32` | strike-through price and Lazada's discount |
| `priceMin` / `priceMax` | `44.54` / `44.54` | across all variants |
| `flashSaleActive` / `flashSaleSold` | `true` / `182` | LazFlash counters while a flash sale runs |
| `rating`, `ratingCount`, `ratingDistribution` | `5`, `1903`, `{"5":1862,"4":36,"3":1,"2":1,"1":3}` | full star histogram |
| `stockStatus`, `orderLimitMin/Max` | `in_stock`, `1` / `200` | |
| `variations[]` | `{skuId, name: "Black / 128 GB", options, price, originalPrice, discountPercent, stockStatus}` | every variant with its own name, price and stock |
| `seller` | `{id, name, url, positiveRatingPercent: 99, soldByStore: 615400, storeAgeYears: 9, repurchaseRatePercent: 47}` | shop link and store badges |
| `vouchers[]` | `["10% off","Min. spend RM60, Cap RM10"]` | |
| `categories[]` | `["Beauty","Makeup","Makeup Removers"]` | breadcrumb |
| `deliveryText`, `deliveryEstimateMin/Max` | `Priority 48H`, `2026-11-03` | delivery window |
| `images[]`, `specifications`, `description` | gallery, spec table, plain text | |

##### Saved copy (default) or ⚡ Live data

**By default a product row is built from Lazada's own saved copy of the product page.** It takes about a second per product, needs no browser, and carries the whole record: every variant with its price and stock, specifications, seller, rating, vouchers, delivery options. A saved copy is not the live page. Lazada makes it on its own schedule: in our measurement of 72 products across the six storefronts the copies were between a few minutes and five and a half days old (half of them older than 29 hours), and on 4 products in 10 the price or the stock of some variant was no longer what the live page showed. Every such row says so:

| Field | Example | Meaning |
|---|---|---|
| `dataFreshness` | `saved-copy` | `saved-copy` or `live` |
| `dataAsOf` | `2026-11-13T10:32:55.865Z` | when the prices and stock on the row were current |
| `dataAgeHours` | `29.4` | how old they were when the row was written; `0` for live rows |
| `dataNote` | *"…come from Lazada's saved copy of the product page, made …"* | the same in words |

**Turn on ⚡ Live data when you need the price and stock as they are right now** — repricing, stock checks, anything a decision hangs on. The Actor then reads every product at run time through a browser session in the storefront's country and never takes a saved copy. It is slower: the first product of each storefront waits 20–45 seconds for the session, the rest take about a second each. A live row is billed as `product_detail_live` instead of `product_detail` (see the price table).

In Thailand and Vietnam a saved copy usually carries the title, categories and specification names in the storefront's own language, while a live read may return Lazada's English translation of them.

About one product in five has no full saved copy on Lazada's side. Those are read live in either mode, the row says `dataFreshness: "live"`, and when you did not ask for live data it is still billed as a plain `product_detail`.

#### 🔍 Search results and 🏪 shop products (one row per product card)

| Field | Example | Notes |
|---|---|---|
| `title`, `brand`, `url`, `image` | | |
| `price`, `originalPrice`, `discountPercent` | `95.55`, `147`, `35` | |
| `priceAfterVoucher` | `85.99` | where Lazada shows a voucher price |
| `rating`, `ratingCount` | `4.96`, `1287` | |
| `soldTotal` | `4230` | lifetime units sold |
| `soldLast7Days` / `soldLast30Days` | `14` / `41` | 🏪 shop products Lazada features on the shop home page |
| `stockStatus`, `location` | `in_stock`, `Selangor` | |
| `seller` | `{id, name, url}` | |
| `query` / `shopUrl`, `shopFollowers` | `air fryer` / shop link, `133176` | |

#### ⭐ Reviews (one row per review)

| Field | Example |
|---|---|
| `rating` | `5` |
| `reviewContent` | `no fragrant. smooth and moist my skin so thoroughly…` |
| `reviewAuthor` | `Y***n` (masked by Lazada) |
| `reviewDate` / `reviewDateText` | `2026-10-03` / `4 weeks ago` |
| `variation` | `Volume:200 ml` |
| `likes`, `images[]`, `videos[]` | `2`, review photos, review videos |
| `sellerReply` | `Glad to serve you…` |
| `productTitle`, `itemId`, `url` | the reviewed product |

Every row starts with `type` (`product`, `product_card`, `review` or `error`), carries `country` and `currency`, and ends with `scrapedAt`. Each mode writes one row type, so the table is never a mix.

### 💰 How much does it cost to scrape Lazada?

Pay only for the rows you get. Error rows (wrong URL, delisted product, no reviews) are **free**.

| Event | Free plan | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| `product_detail` — one 📦 full product row | $3.20 / 1,000 | $2.40 / 1,000 | $1.60 / 1,000 | $1.60 / 1,000 |
| `product_detail_live` — one 📦 product row read live at run time (⚡ Live data or a monitoring run), charged **instead of** `product_detail` | $8.90 / 1,000 | $7.90 / 1,000 | $6.90 / 1,000 | $6.50 / 1,000 |
| `product_card` — one 🔍 search or 🏪 shop card | $3.20 / 1,000 | $2.40 / 1,000 | $1.60 / 1,000 | $1.60 / 1,000 |
| `review` — one ⭐ review row | $1.20 / 1,000 | $1.03 / 1,000 | $0.87 / 1,000 | $0.79 / 1,000 |

`product_detail_live` applies from the day it appears in the price list on this page (Apify lets a price change once a month; it is due in December 2026). Until then live rows are billed as `product_detail`.

Apify also charges a small start fee per run ($0.005 per GB of memory, about $0.01 per run). On a paid plan that is about **625 products per $1**, and a 388-product shop catalog costs about **$0.63**. Set **Max cost per run** in the run options and the Actor stops exactly there, with everything written already paid for.

### How to scrape Lazada with Lazada Scraper

1. Pick **🧭 What to scrape**: 📦 Product details, 🔍 Search results, 🏪 Shop products or ⭐ Reviews.
2. Paste **product URLs**, **keywords** (and choose a **🌎 Country**), or **shop URLs**.
3. Set **💯 Max products** (and **⭐ Max reviews per product** for reviews).
4. Press **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

### ⬇️ Input

![Lazada Scraper input form: mode, product URLs, search keywords, shop URLs, country, max products](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/lazada-bluesky/lazada-scraper-input-form.png)

#### 📦 Product details

```json
{
  "mode": "product",
  "productUrls": [
    "https://www.lazada.com.my/products/pdp-i135513465-s153555036.html",
    "https://www.lazada.co.th/products/pdp-i124821653.html"
  ]
}
```

The same products with prices and stock read at run time:

```json
{
  "mode": "product",
  "productUrls": ["https://www.lazada.com.my/products/pdp-i135513465-s153555036.html"],
  "liveData": true
}
```

#### 🔍 Search results

```json
{
  "mode": "search",
  "country": "th",
  "searchQueries": ["air fryer", "rice cooker"],
  "maxItems": 200
}
```

The Actor walks Lazada's result pages (40 cards each) until it has `maxItems` cards per keyword.

#### 🏪 Shop products

```json
{
  "mode": "shop",
  "shopUrls": ["https://www.lazada.com.my/shop/my-mentholatum/"],
  "maxItems": 500
}
```

The whole "All products" catalog of the shop, page by page.

#### ⭐ Reviews

```json
{
  "mode": "reviews",
  "productUrls": ["https://www.lazada.com.my/products/pdp-i135513465-s153555036.html"],
  "maxReviewsPerProduct": 100,
  "reviewsRating": "all"
}
```

### ⬆️ Output

![Lazada Scraper output table: product titles, prices, discounts, ratings, sold counts and sellers](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/lazada-bluesky/lazada-scraper-output-table.png)

#### 📦 Product row

```json
{
  "type": "product",
  "itemId": "135513465",
  "skuId": "153555036",
  "title": "HADA LABO Hydrating Cleansing Oil 200ml (Upgraded Formula)",
  "brand": "Hada Labo",
  "url": "https://www.lazada.com.my/products/pdp-i135513465-s153555036.html",
  "country": "my",
  "currency": "MYR",
  "price": 44.54,
  "originalPrice": 65.5,
  "discountPercent": 32,
  "rating": 5,
  "ratingCount": 1903,
  "ratingDistribution": {"1": 3, "2": 1, "3": 1, "4": 36, "5": 1862},
  "stockStatus": "in_stock",
  "seller": {
    "id": "100040635",
    "name": "MY Mentholatum",
    "url": "https://www.lazada.com.my/shop/my-mentholatum/",
    "positiveRatingPercent": 99,
    "soldByStore": 615400,
    "storeAgeYears": 9
  },
  "vouchers": ["10% off", "Min. spend RM60, Cap RM10"],
  "deliveryEstimateMin": "2026-11-03",
  "dataFreshness": "saved-copy",
  "dataAsOf": "2026-10-30T07:12:03.118Z",
  "dataAgeHours": 29.5,
  "dataNote": "Prices, stock, vouchers, delivery dates and rating counts on this row come from Lazada's saved copy of the product page, made 2026-10-30T07:12:03.118Z (29.5 hours before this run). They may have changed since. Turn on \"Live data\" in the input to read them at run time.",
  "scrapedAt": "2026-10-31T12:39:41.350Z"
}
```

#### 🏪 Shop card

```json
{
  "type": "product_card",
  "itemId": "442671647",
  "title": "Hada Labo Hydrating Lotion Rich 170ml x2 - For Normal / Dry skin",
  "price": 95.55,
  "originalPrice": 147,
  "discountPercent": 35,
  "rating": 4.96,
  "ratingCount": 1287,
  "soldTotal": 4230,
  "soldLast7Days": 14,
  "soldLast30Days": 41,
  "stockStatus": "in_stock",
  "seller": {"id": "100040635", "name": "MY Mentholatum", "url": "https://www.lazada.com.my/shop/my-mentholatum/"},
  "shopFollowers": 133176
}
```

#### ⭐ Review row

```json
{
  "type": "review",
  "itemId": "135513465",
  "productTitle": "HADA LABO Hydrating Cleansing Oil 200ml (Upgraded Formula)",
  "rating": 5,
  "reviewContent": "no fragrant. smooth and moist my skin so thoroughly. highly recommended to buy.",
  "reviewAuthor": "Y***n",
  "reviewDate": "2026-10-03",
  "reviewDateText": "4 weeks ago",
  "variation": "Volume:200 ml",
  "likes": 2,
  "sellerReply": "Glad to serve you and to know that you like our service and product."
}
```

### Use cases for Lazada data

#### Price monitoring and repricing

Schedule a watchlist on your competitors' product URLs: `changeType`, `priceChange` and `flashSaleActive` show every price move the day it happens, and `stockChanged` shows when a competitor sells out or restocks — the moment to raise your own price.

#### MAP and brand monitoring

Brands watch resellers on a search or shop watchlist and get a row with `changeType: price-down` whenever someone undercuts the minimum advertised price.

#### Sales tracking

`soldDelta` between scheduled runs of a shop or search watchlist estimates how many units each product sold per day.

#### Competitor shop analysis

🏪 Shop mode returns a competitor's whole catalog with prices, discounts, ratings and lifetime sold counts, plus 7- and 30-day sales for the products the shop features.

#### Market and assortment research

🔍 Search returns hundreds of cards per keyword with price, rating, sold count and seller — enough to map a category's price bands and which listings actually sell.

#### Review mining and product feedback

⭐ Reviews come with full text, attribute lines ("Effectiveness: …"), photos, videos and the seller's reply — ready for sentiment analysis, listing copy and support triage.

#### Catalogs for AI and RAG

Flat rows with stable field names drop into a spreadsheet, a database or a vector index without cleaning.

### Integrations

- **Apify API**: run the Actor with `run-sync-get-dataset-items` and get JSON back in one call.
- **Python / JavaScript**: the `apify-client` package (example below).
- **n8n, Make, Zapier, Google Sheets, Airtable**: use the Apify integration or an HTTP node; set a max cost per run so a loop cannot overspend.
- **MCP server**: AI agents can call it through the Apify MCP server (`mcp.apify.com`).
- **Webhooks**: subscribe to `ACTOR.RUN.SUCCEEDED` and fetch the dataset.

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("blueskyscraper/lazada-product-scraper").call(run_input={
    "mode": "shop",
    "shopUrls": ["https://www.lazada.com.my/shop/my-mentholatum/"],
    "maxItems": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["currency"], item.get("soldTotal"))
```

### 🤖 For AI agents

**Minimal input.** `{"mode": "product", "productUrls": ["https://www.lazada.com.my/products/pdp-i135513465-s153555036.html"]}`. Keywords need a storefront: `{"mode": "search", "country": "th", "searchQueries": ["air fryer"]}`. A shop: `{"mode": "shop", "shopUrls": ["https://www.lazada.com.my/shop/my-mentholatum/"]}`.

**Behaviour.** `maxItems` caps products per keyword, per shop, or in total for product URLs. Prices are numbers in the local currency (`IDR`, `SGD`, `MYR`, `THB`, `PHP`, `VND`) — convert before comparing countries. `soldTotal` is a lifetime counter shown on search and shop cards; Lazada no longer prints it on product pages, so product rows carry `seller.soldByStore` instead. Error rows explain the failure and are never charged; `kind: "no-results"` means the target simply has nothing (no reviews, no matches).

### ❓ FAQ

#### Is it legal to scrape Lazada?

The Actor collects only public data that any visitor sees without logging in. Reviewer names arrive already masked by Lazada. Personal data is protected by laws such as GDPR and PDPA; if you are unsure about your use case, consult a lawyer.

#### Can I track Lazada prices automatically?

Yes. Give the run a watchlist name and add a schedule (daily, hourly or any cron). Each run compares itself with the previous one and marks every row `new`, `price-down`, `price-up`, `stock` or `unchanged`. Connect a webhook, Slack, Google Sheets, Make or n8n to receive only the changes.

#### Can I use Lazada Price Tracker with the Apify API?

Yes. Every run can be started, scheduled and read through the Apify API or the `apify-client` libraries for Python and JavaScript.

#### Can I use it through an MCP server?

Yes. Connect the Apify MCP server to Claude, ChatGPT or any MCP client and the agent can call `blueskyscraper/lazada-product-scraper` directly — for example "check my Lazada watchlist and tell me which competitor dropped the price today".

#### Can I integrate it with other apps?

Yes — n8n, Make, Zapier, Google Sheets, Airtable, Slack and webhooks all work through Apify integrations.

#### How much does a typical run cost?

100 products on a paid plan cost about $0.16 plus the $0.01 start fee. Reviews are $0.79–1.20 per 1,000.

#### Is there one row per product?

One row per product in 📦 Product details, one per card in 🔍 Search and 🏪 Shop, one per review in ⭐ Reviews. Error rows are rows too, but free.

#### Do I need Lazada cookies, a login or an API key?

No. The Actor needs only a residential IP in the storefront's country, which it provides itself.

#### Why is Singapore slower to start?

The Singapore storefront challenges some residential exits. The Actor rotates exits and falls back to Apify Proxy; the first minute can go to opening a session, after which products are fast.

#### How fresh are the prices on a product row?

It depends on the mode, and the row tells you. By default the row comes from Lazada's saved copy of the product page: `dataFreshness` is `saved-copy` and `dataAsOf` is the moment the copy was made, usually hours to a few days before your run. With **⚡ Live data** on, and in every monitoring run, the product is read at run time and `dataFreshness` is `live`. Search and shop cards are always read at run time.

#### Why does a product row have no sold count?

Lazada removed the per-product sold counter from product pages. Use 🔍 Search or 🏪 Shop mode for `soldTotal`; product rows carry the store's total in `seller.soldByStore`.

### Your feedback

Missing a field or a storefront feature? Open an issue on the Actor's Issues tab — we read every one and field requests ship fast. A short review on the Actor page helps other buyers find it.

### You might also like

| Actor | What it does |
|---|---|
| [Alibaba Scraper](https://apify.com/blueskyscraper/alibaba-scraper) | Alibaba.com products, suppliers and prices |
| [1688 Product Details Scraper](https://apify.com/blueskyscraper/1688-product-details-scraper) | 1688.com factory products, variants and wholesale prices |
| [1688 Image Search Scraper](https://apify.com/blueskyscraper/1688-image-search-scraper) | Find the factory source of a product by its photo |
| [Google Shopping Scraper](https://apify.com/blueskyscraper/google-shopping-scraper) | Google Shopping prices and sellers |

# Actor input Schema

## `mode` (type: `string`):

Pick what you need. 📦 Product details: one full row per product URL. 🔍 Search: product cards for keywords. 🏪 Shop: every product of a shop, with 7- and 30-day sales where Lazada shows them. ⭐ Reviews: review rows for product URLs.

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

Add Lazada product URLs from any of the six storefronts, e.g. <code>https://www.lazada.com.my/products/pdp-i135513465-s153555036.html</code>, or bare numeric item ids (then set 🌎 Country). Used by the 📦 Product details and ⭐ Reviews modes.

## `searchQueries` (type: `array`):

Enter keywords to search on the storefront chosen in 🌎 Country, e.g. <code>rice cooker</code>. Each keyword returns up to 💯 Max products cards with price, discount, rating, sold count and seller. Used by the 🔍 Search mode.

## `shopUrls` (type: `array`):

Paste Lazada shop URLs as they open in the browser, e.g. <code>https://www.lazada.com.my/shop/my-mentholatum/</code>. Each shop returns its whole catalog, up to 💯 Max products. Used by the 🏪 Shop mode.

## `country` (type: `string`):

Lazada storefront. Required for 🔍 Search, because keywords carry no country. URLs always use their own storefront, so leave it on Auto for them.

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

Set how many products to return per keyword, per shop, or in total for product URLs (also caps how many products the ⭐ Reviews mode reads). Keeps the bill predictable.

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

Set how many reviews to collect per product in the ⭐ Reviews mode. Each review is billed as one Review event.

## `reviewsRating` (type: `string`):

Keep only reviews with this star rating (⭐ Reviews mode). Lazada filters them itself, so you pay only for the reviews you asked for.

## `includeSpecifications` (type: `boolean`):

Add the specification table (brand, SKU, material, dimensions…) to every product row. Included in the Product detail price.

## `includeDescription` (type: `boolean`):

Add the plain-text product description to every product row. Turn off to keep rows compact.

## `liveData` (type: `boolean`):

Off (default): a product row is built from Lazada's own saved copy of the product page. It is fast and complete, and every row says when the copy was made (`dataAsOf`, `dataAgeHours`) — usually hours to a few days before the run, so a price or a stock status may have changed since. On: every product is read at run time through a browser session in the storefront's country — slower, always current, billed as `product_detail_live` instead of `product_detail` once that event is in the price list. Turn it on for repricing and stock checks. Runs with a 📈 Watchlist name or a previous dataset always read live and are billed the same way.

## `watchlistName` (type: `string`):

Give your list a name, for example my-competitors, and schedule the Actor daily or hourly. Each run is compared with the previous run of the same watchlist: every row gets changeType (new, price-down, price-up, stock, unchanged), previousPrice, priceChange, priceChangePercent, stockChanged and soldDelta. The history is kept in a named key-value store on your own account (lazada-watch-<name>). Free — no extra charge.

## `previousDatasetId` (type: `string`):

Optional one-off comparison: pick the dataset of an earlier run. Every row then gets changeType, previousPrice, priceChange, priceChangePercent, stockChanged, soldDelta, soldLast7DaysDelta, daysSincePrevious and isNew. For scheduled monitoring use the watchlist name above instead. Free.

## `parallelism` (type: `integer`):

Set how many product requests run at once inside one warm Lazada session (📦 Product details mode). 4 balances speed and anti-bot tolerance.

## `proxyMode` (type: `string`):

Own pool first tries the Actor's built-in residential pool and falls back to Apify Proxy when a country refuses it. Apify Proxy only always uses Apify Proxy. Own pool only never falls back.

## `proxyUrl` (type: `string`):

Bring your own residential proxy in the storefront's country, e.g. <code>http://user:pass@host:port</code>. When set, it replaces the built-in pool.

## Actor input object example

```json
{
  "mode": "product",
  "productUrls": [
    "https://www.lazada.com.my/products/pdp-i135513465-s153555036.html"
  ],
  "country": "auto",
  "maxItems": 100,
  "maxReviewsPerProduct": 20,
  "reviewsRating": "all",
  "includeSpecifications": true,
  "includeDescription": true,
  "liveData": false,
  "parallelism": 4,
  "proxyMode": "own-first"
}
```

# Actor output Schema

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

Every scraped row: full product records, search cards, review records and non-charged error rows.

## `summary` (type: `string`):

Counts per row type, the proxy provider used per country, timing and errors.

# 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.lazada.com.my/products/pdp-i135513465-s153555036.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/lazada-product-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.lazada.com.my/products/pdp-i135513465-s153555036.html"] }

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/lazada-product-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.lazada.com.my/products/pdp-i135513465-s153555036.html"
  ]
}' |
apify call blueskyscraper/lazada-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,blueskyscraper/lazada-product-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/z64J73k7c8DWRwfMi/builds/2Niw4wPnt4Vy8sacA/openapi.json