# Lazada Product Scraper & API: Prices, Stock, Sold Count (`hyperbach/lazada-product-scraper`) Actor

Lazada scraper and API for Singapore, Malaysia, Philippines, Thailand, Vietnam and Indonesia: products by keyword, category, product or store link with price, discount, rating, sold count, seller, every variant's stock, product details and reviews. No login. Misses free.

- **URL**: https://apify.com/hyperbach/lazada-product-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 products

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

## Lazada Product Scraper & API: Prices, Stock, Sold Count

**Lazada products, logged out, on all six marketplaces (Singapore, Malaysia, the Philippines, Thailand, Vietnam, Indonesia): keywords, search links, category links, product links or ids and store links in, one row per product out — the price and its text, the original price and the discount, the ISO currency, the unrounded rating, the review count, the sold count, the seller, the brand, LazMall, where it ships from, the badges and its place in the list.** Turn on `includeDetails` (product links always have it) for every variant with its price and its stock, the specifications, the description, delivery, warranty, vouchers and the seller's ratings; turn on `includeReviews` for review rows. One free `target` row per input carries a verdict and Lazada's own count. No login, no cookies, no browser, proxies handled for you.

**From $3.99 per 1,000 rows (`product`) on the Free plan, $2.99 on Starter; every row and add-on is priced under Pricing below.** A run start is $0.013945. The default input returns about 51 rows for about $0.2134. A product id the marketplace does not have (checked on a second connection), a keyword Lazada finds nothing relevant for, an unknown category or store link and a list still refused after 40 fresh connections each get a free row that says what Lazada answered.

![A Lazada product page in a browser: a glass electric kettle with its price, the original price and the discount, the star rating, the ratings count, the sold count, two colour variants and the stock left. Beside it, the row this Actor returns, with skus highlighted (each colour with its stock), then the title, price, original price, discount, rating, review count, sold count and seller.](https://api.apify.com/v2/key-value-stores/dcLLNGq99686o2A4v/records/hero-lazada-product-scraper.webp)

### How it compares

- **3 times faster than fatihtahta's Lazada Scraper, with more data:** 50 products in 7.2 s, against 19 s; 38 fields per product, against 16. It is cheaper: $1.99 per 1,000 products, against our $2.27.

Measured on 2026-11-13. Each line compares one job, run by both scrapers at the same time. Prices are per 1,000 products: Apify Actors at the Scale plan's prices.

### Tested head-to-head on 2026-11-13

The job: the first 50 Lazada Singapore products for the keyword "wireless earbuds" (the input schema's example), each with its price, rating, sold count and seller. Every Actor ran on it the same day from the same harness; every run's cost is at the Scale plan's prices: a rival's charged events at its price for that plan, this Actor's at its list price. Fields counts the filled fields of a typical row. Every row here is a product card of the same keyword on Lazada Singapore; both rivals charge each row, and our rows carry the ISO currency, the unrounded rating and the sold count as a number. Re-measured monthly.

| Actor | Rows | First row | Run time | Cost | Fields | Failures |
|---|---|---|---|---|---|---|
| **this Actor** | 50 | 6.4 s | 7.2 s | $0.11 | 38 | none |
| `fatihtahta/lazada-scraper` | 50 | 18 s | 19 s | $0.100 | 16 | none |

### Why this Lazada scraper

- **Every variant's stock, as a number.** With `includeDetails` (and on every product link) each row carries every variant with its price, its original price, its coupon price and its stock: Lazada's per-variant `limit` is the stock left when it is under the marketplace's per-order cap (Singapore 50, Vietnam 10, Indonesia 20, measured over 296 variants of 73 products on 2026-11-13; Thailand showed 18 and 30, so no cap is assumed there), so `stock` is the number left and `stock_at_least` says "at least 50" above it, beside Lazada's own `Almost sold out` and `Out of stock` texts. When every variant of a product shows one and the same number, that number is the seller's purchase limit, so it goes to `stock_at_least`, never to `stock`. One variant's stock read 18, then 15 seventy-four minutes later, while its siblings held.
- **All six marketplaces, in English, with the right currency.** lazada.sg, .com.my, .com.ph, .co.th, .vn and .co.id: every list is asked in English (without it Lazada answers in Thai or Vietnamese on a share of calls), and each row carries the marketplace's ISO currency (SGD, MYR, PHP, THB, VND, IDR) and a numeric price, never only the shown text. An answer whose own marketplace field names another country is read again, never delivered.
- **Sold count, rating and seller from the list itself.** The search card's sold count (`2.0K sold` → 2000, with `sold_count_exact` false where Lazada rounds), the unrounded rating (4.9641, not 5.0), the review count, the seller, the brand, LazMall, where it ships from and the badges come on every row; a product link's row gets its card through Lazada's own search for the item id, so it has the sold count too.
- **Stores read to their own count, with last week's and last month's sales.** A store link reads the store's own catalogue route, 100 products a call, to the store's own product count and one call past it; each row carries the units sold in the last 7 and 30 days and the listing date.
- **Honest runs.** Lazada answers a slider captcha to a share of fresh connections by the minute: the walk moves to a fresh connection at once and goes on, and a list still refused after 40 connections gets a free row that says so, never a silent stop. A product id the marketplace does not have is a free `not_found` row checked on a second connection; a product two inputs list is delivered and charged once; every input gets a row with its verdict and Lazada's own count.

### Who it's for

- **Lazada sellers and brands** — their own and their competitors' products on one or all six marketplaces: today's price and discount, sold count, rating, the stock of every variant and the vouchers, read in the same minute.
- **Product researchers and dropshippers** — what Lazada lists for a word or in a category, with prices, sold counts, ratings, sellers and where each ships from, to pick products and suppliers.
- **Market and price analysts** — a store's whole catalogue with its 7-day and 30-day sales, or a list of product links read on a schedule, to see a price or stock change the day it happens.

### Quick start

**The first 50 products for a keyword on lazada.sg**

```json
{
  "searchKeywords": [
    "wireless earbuds"
  ],
  "maxItemsPerInput": 50
}
```

**Product links with every variant's price and stock**

```json
{
  "startUrls": [
    "https://www.lazada.sg/products/pdp-i3049365543.html"
  ]
}
```

**A store's catalogue with its weekly and monthly sales**

```json
{
  "startUrls": [
    "https://www.lazada.sg/shop/anker-official-shop/"
  ],
  "maxItemsPerInput": 200
}
```

### Switching from `fatihtahta/lazada-scraper`?

Your input works as it is. Each name in the left column is read as this Actor's own field and the run log says so (`read <theirs> as <ours>`); a name marked *not read* is ignored with a note. A value in the other Actor's shape, an object list or its own date form, is read too.

| fatihtahta/lazada-scraper | this Actor | what to know |
|---|---|---|
| `startUrls` | `startUrls` | Search, category, product and store links of the six marketplaces, and bare item ids; each read by its form. A search link keeps its own price, rating, sort and service filters. |
| `queries` | `searchKeywords` | Keywords, one search each, on the marketplace of `country`. |
| `country` | `country` | sg, my, ph, th, vn or id: the marketplace of keywords and bare ids; a link keeps its own. |
| `limit` | `maxItemsPerInput` | The most product rows of each keyword, search link, category or store (default 100 here, 50,000 there). |
| `enrich_data` | `includeDetails` | Every variant with price and stock, specifications, description, delivery, warranty, vouchers, seller ratings. |
| `getReviews` | `includeReviews` | Review rows of each product. |
| `maxReviews` | `maxReviewsPerProduct` | The most review rows of each product (default 20). |
| `minPrice` | `minPrice` | Sent to Lazada for keywords and categories and checked on every row. |
| `maxPrice` | `maxPrice` | Sent to Lazada for keywords and categories and checked on every row. |
| `minimumRating` | `minRating` | 1 to 5 (the leader's text values `4` read as 4). |
| `sort` | `sort` | popularity (the leader's `best`), priceasc or pricedesc. |

**What differs:**

- The leader's `queries` are read as `searchKeywords`, its `startUrls` as they are (search, category and product links, and here store links and bare item ids too), `limit` as `maxItemsPerInput`, `enrich_data` as `includeDetails`, `getReviews` and `maxReviews` as `includeReviews` and `maxReviewsPerProduct`, `minimumRating` as `minRating` and its `sort` value `best` as `popularity`.
- The leader's `limit` defaults to 50,000 a target; here `maxItemsPerInput` defaults to 100, so a run without a limit cannot bill a whole search by surprise. A Lazada search shows one connection's view of 1,459 to about 2,000 items of its count in any case (the list wraps after that).
- Rows are flat: `price`, `original_price`, `discount_percent`, `currency`, `rating`, `sold_count`, `seller_name` and so on at the top level, every variant in `skus` with its own price and stock, not a nested contract.
- Reviews are their own rows (`record_type` review) and their own event, like the leader's review records.

### Output

One row per product (and per review when asked, and one free summary row per input):

| field | meaning |
|---|---|
| `record_type` | `product` on a product row (charged), `review` on a review row (charged, only with `includeReviews`), `target` on an input's free summary row. |
| `status` | `ok`, or why an input gave no row: `not_found`, `no_results`, `invalid_input`, `refused`, `app_only` (a product link whose web page Lazada sends to its app and that no search card lists), `failed` or `not_read` (all free). |
| `input` | The keyword, link or id you gave that this row answers. |
| `country` | The marketplace the row was read from: `sg`, `my`, `ph`, `th`, `vn` or `id`. |
| `id` | Lazada's item id on a product row; the review's own id on a review row. |
| `url` | The product's page on its marketplace. |
| `title` | The product's title as the search card shows it (the English view of the list; a product link's title from its card, else from its page). |
| `price` | The price the buyer pays now, in `currency` (the default variant's price on a row with the product page's detail). |
| `price_text` | The price as Lazada shows it (`$54.00`, `RM54.15`, `₫950,000`). |
| `original_price` | The struck-through original price; null when Lazada shows none above the price. |
| `discount_percent` | The discount Lazada shows, in percent (26 for -26%); null when there is no original price above the price. |
| `currency` | The ISO currency of the marketplace: SGD, MYR, PHP, THB, VND or IDR. |
| `price_min` | The lowest price over the variants in stock (rows with the product page's detail). |
| `price_max` | The highest price over the variants in stock (rows with the product page's detail). |
| `rating` | The product's rating out of 5 as Lazada keeps it, unrounded (4.9641); on a review row, the review's stars. Null when the product has no rating yet. |
| `review_count` | The product's number of ratings and reviews. |
| `rating_histogram` | Ratings per star, `{"5": 594, "4": 14, …}` (rows with the product page's detail). |
| `sold_count` | Items sold as the search card shows it, as a number (`2.0K sold` → 2000). |
| `sold_text` | The sold count as Lazada shows it (`2.0K sold`, `13.5K sold*`). |
| `sold_count_exact` | False when Lazada rounds the sold count (`2.0K`, `1.2M`), true when it shows the exact number. |
| `sold_last_week` | Units sold in the last 7 days, as the store's own catalogue shows it (store rows only). |
| `sold_last_month` | Units sold in the last 30 days, as the store's own catalogue shows it (store rows only). |
| `in_stock` | True when the product (any variant on a detailed row) can be bought now. |
| `brand` | The brand name. |
| `brand_id` | Lazada's brand id. |
| `seller_name` | The seller's store name. |
| `seller_id` | Lazada's seller id. |
| `store_id` | The store's shop id (the id in a store's page data). |
| `store_url` | The seller's store page (rows with the product page's detail). |
| `ships_from` | Where the product ships from, as the card shows it (`Singapore`, `China`, `Overseas`). |
| `is_lazmall` | True for a LazMall (official brand) store's product. |
| `free_shipping` | True when the card shows the free-shipping badge. |
| `seller_rating` | The seller's positive rating as the product page shows it (`99%`). |
| `seller_tags` | The store's badges as the product page shows them (`5-Year Store`, `40.7K Sold by Store`, `Quick replies: Avg. 2 mins`). |
| `category_ids` | Lazada's category ids of the product, from the card (top level first). |
| `category_path` | The category names from the top level down (`Audio` › `Headphones & Headsets` › `Wireless Earbuds`), rows with the product page's detail; in the marketplace's own language. |
| `image` | The product's main image. |
| `images` | The product's gallery images (the detail's gallery, else the card's variant images). |
| `video_id` | The id of the product's video, when its gallery has one (Lazada serves no video link to a logged-out reader's data call). |
| `badges` | The card's badges by Lazada's own names: `lazMall`, `Freeshipping`, `coins`, `campaign`, `choice`, `new`, … |
| `badge_texts` | The card's badge texts as Lazada shows them (`Coin save $3.30`, `New`); null when the card's badges are icons only. |
| `is_sponsored` | True when the card is a sponsored placement in that read of the list. |
| `flash_sale` | A running LazFlash sale of the default variant: `sold`, `total`, `status`, `text`. |
| `vouchers` | The voucher offers the product page shows (`$4.00 off`, `15% off`). |
| `promotion_tags` | The promotions the product page names: `kind`, `name`, `description`. |
| `sku_id` | The default variant's id. |
| `sku_count` | The number of variants (SKUs). |
| `skus` | Every variant: `sku_id`, `options` (Color Family, Size, …), `price`, `price_text`, `original_price`, `discount_percent`, `coupon_price`, `stock` (the number left when it is under the marketplace's per-order cap), `stock_at_least` (the cap when the variant has at least that many), `stock_text` (`Almost sold out, buy now!`, `Out of stock`), `in_stock`, `image`, `seller_sku`. |
| `description` | The product description as text (the page's HTML without its markup). |
| `highlights` | The product's highlights as text, when the page has them. |
| `specifications` | The specification table of the default variant (`Brand`, `Model`, `Bluetooth version`, …), in the marketplace's own language. |
| `delivery_options` | The delivery options to the marketplace's default address: `type`, `title`, `fee`, `fee_value`, `time`. |
| `warranty` | The warranty and return terms the page shows: `type`, `title`, `description`. |
| `listed_at` | When the product was listed (store rows only). |
| `position` | The product's place in its list (1 = the first card), on rows of a keyword, category or store. |
| `page` | The list page the product was on (40 cards a page), on rows of a keyword or category. |
| `total_results` | The source's own count of the list: the search engine's `items found` for a keyword or category, the store's product count for a store. |
| `card_status` | The item's search card, the only source of the sold count, ships-from and the badges: `served` (every row of a keyword or a category; a product link's card found by Lazada's own search for the id), `refused` (a product link whose card search was refused on every connection tried: the row has the product page's fields and says so; its input's row is PARTIAL), `not_listed` (the search lists no card for the id); null on a store's rows. |
| `detail_status` | What the product page's data call did for this row: `served`, `refused` (every connection tried was refused: the row has the card's fields), `not_found`, `app_only` (Lazada sends this product's web page to its app — "pc spu redirect" — so the row has the card's fields), `not_asked` (`includeDetails` off) or `cut` (the run's time limit or abort came first). |
| `reviews_status` | With `includeReviews`: `served`, `none` (the product has no review), `refused` or `cut`. |
| `product_id` | On a review row: the product's item id. |
| `review_text` | On a review row: the review's text. |
| `reviewer_name` | On a review row: the reviewer's name as Lazada shows it (masked, `b***n`). |
| `review_date` | On a review row: the date of the review as Lazada shows it (`13 Oct 2026`). |
| `purchase_date` | On a review row: the date the reviewer bought the item (`11 Oct 2026`). |
| `variant` | On a review row: the variant the reviewer bought (`Color Family:Black`). |
| `review_images` | On a review row: the reviewer's photos. |
| `review_video_url` | On a review row: the reviewer's video. |
| `seller_reply` | On a review row: the seller's reply, when there is one. |
| `helpful_count` | On a review row: how many buyers found it helpful. |
| `verified_purchase` | On a review row: true when Lazada marks the review as from a buyer of the item. |
| `verdict` | On a target row: COMPLETE (the list's end at or past the source's count; a product link with both its reads), TRUNCATED (the list ended under the source's count: a search shows one connection's view of 1,459 to about 2,000 items), CAPPED (your `maxItemsPerInput` or the run's `maxItems`), PARTIAL (stopped, or a product link with its card or its page data refused: `note` names the missing columns), DUPLICATE (a product link another input delivered first). |
| `rows_delivered` | On a target row: the product rows it delivered. |
| `reviews_delivered` | On a target row with `includeReviews`: the review rows it delivered. |
| `note` | Why a target row has its status or verdict, in the source's own words where it gave some. |
| `scraped_at` | When this row was read (UTC). |

Example record:

```json
{
  "record_type": "product",
  "status": "ok",
  "input": "https://www.lazada.sg/products/pdp-i2939581030.html",
  "country": "sg",
  "id": "2939581030",
  "url": "https://www.lazada.sg/products/pdp-i2939581030.html",
  "title": "Russell Taylors Digital Low Sugar Rice Cooker (1.8L) RC10/ RC9 (1.2L)",
  "price": 59.99,
  "price_text": "$59.99",
  "original_price": 150,
  "discount_percent": 60,
  "currency": "SGD",
  "price_min": 59.99,
  "price_max": 69.99,
  "rating": 4.9534,
  "review_count": 343,
  "rating_histogram": {
    "1": 1,
    "2": 0,
    "3": 1,
    "4": 10,
    "5": 331
  },
  "sold_count": 1000,
  "sold_text": "1.0K sold",
  "sold_count_exact": false,
  "sold_last_week": null,
  "sold_last_month": null,
  "in_stock": true,
  "brand": "Russell Taylors",
  "brand_id": "127843066",
  "seller_name": "Russell Taylors",
  "seller_id": "1134141547",
  "store_id": "557064",
  "store_url": "https://www.lazada.sg/shop/russell-taylors/",
  "ships_from": "Singapore",
  "is_lazmall": true,
  "free_shipping": true,
  "seller_rating": "98%",
  "seller_tags": [
    "Top 18 Seller for Household Cleaning",
    "57.4K Sold by Store",
    "6-Year Store",
    "Fast Shipping: 100% Shipped in 48 hrs",
    "105 Repeat Customers"
  ],
  "category_ids": [
    "275",
    "276",
    "62551406",
    "62551607",
    "10000278"
  ],
  "category_path": [
    "Home Appliances",
    "Kitchen Appliances",
    "Cooking Equipment",
    "Cookers",
    "Rice Cookers"
  ],
  "image": "https://sg-live-01.slatic.net/p/b1d7c4954852e6ae2992b66030b34e1a.jpg",
  "images": [
    "https://laz-img-sg.alicdn.com/p/b1d7c4954852e6ae2992b66030b34e1a.jpg",
    "https://laz-img-sg.alicdn.com/p/2e64e807b22811c018fbef5665ff0684.jpg",
    "https://laz-img-sg.alicdn.com/p/309cb1ac9eb557d11ec44593e824bb63.jpg",
    "https://laz-img-sg.alicdn.com/p/c23121cce64f1b00ba542467a7e04983.jpg",
    "https://laz-img-sg.alicdn.com/p/339b132a8eca1c11822af8f3c6c14016.jpg",
    "https://laz-img-sg.alicdn.com/p/b8fedafc52a9684b88e9e63d132513ba.jpg",
    "https://laz-img-sg.alicdn.com/p/c0103ea2ec0e68c69562d5d7aff98f44.jpg",
    "https://laz-img-sg.alicdn.com/p/92008ef4d061a356ce4388b517467ef1.jpg",
    "https://laz-img-sg.alicdn.com/p/351ed7ded66f48a028b9204cd9ce8bbd.jpg"
  ],
  "video_id": "8000013394662",
  "badges": [
    "Freeshipping",
    "campaign",
    "lazMall"
  ],
  "badge_texts": null,
  "is_sponsored": false,
  "flash_sale": null,
  "vouchers": [
    "$24.00 off",
    "$15.00 off"
  ],
  "promotion_tags": [
    {
      "kind": "voucher",
      "name": "$24",
      "description": "with min spend of $160.00 from Russell Taylors"
    }
  ],
  "sku_id": "23838895409",
  "sku_count": 2,
  "skus": [
    {
      "sku_id": "23838895409",
      "options": {
        "Models": "RC9 (1.2L)"
      },
      "price": 59.99,
      "price_text": "$59.99",
      "original_price": 150,
      "discount_percent": 60,
      "coupon_price": null,
      "stock": null,
      "stock_at_least": 50,
      "stock_text": null,
      "in_stock": true,
      "image": "https://laz-img-sg.alicdn.com/p/351ed7ded66f48a028b9204cd9ce8bbd.jpg",
      "seller_sku": "2939581030_SGAMZ-23838895409"
    },
    {
      "sku_id": "23838895408",
      "options": {
        "Models": "RC10 (1.8L)"
      },
      "price": 69.99,
      "price_text": "$69.99",
      "original_price": 159.99,
      "discount_percent": 56,
      "coupon_price": null,
      "stock": null,
      "stock_at_least": 50,
      "stock_text": null,
      "in_stock": true,
      "image": "https://laz-img-sg.alicdn.com/p/b1d7c4954852e6ae2992b66030b34e1a.jpg",
      "seller_sku": "2939581030_SGAMZ-23838895408"
    }
  ],
  "description": "⚡️ 𝗣𝗿𝗼𝗱𝘂𝗰𝘁 𝗛𝗶𝗴𝗵𝗹𝗶𝗴𝗵𝘁𝘀 ⚡️\n📌 More than just a rice cooker! Its 9-in-1 functionality lets you perform miracles in the kitchen\n📌 All-new Sugar Reducing technology minimizes starches in …(truncated for display)",
  "highlights": null,
  "specifications": {
    "Brand": "Russell Taylors",
    "Rice Cooker Features": "Fast Cooking,Removable Inner Pot",
    "Control Method": "Automatic Control",
    "Material": "Metal,Plastic,Stainless Steel",
    "Maximum persons": "8",
    "Power Consumption (W)": "900 W",
    "Model": "rc10/ rc9",
    "Type of Rice Cooker": "Fuzzy Logic (Digital)",
    "Input Voltage": "220 - 240v"
  },
  "delivery_options": [
    {
      "type": "standard",
      "title": "Standard",
      "fee": "$1.99",
      "fee_value": 1.99,
      "time": "Guaranteed by 17-19 Nov"
    }
  ],
  "warranty": [
    {
      "type": "authenticity",
      "title": "100% Authentic",
      "description": "100% Authentic. Get 2 times your money back if you receive a non-authentic product from LazMall * Terms & conditions apply"
    },
    {
      "type": "change_mind_available",
      "title": "Change of Mind",
      "description": "You can return the product for Change of Mind if it meets the condition: Fashion items may be opened and tried on but must be clean, undamaged, unaltered, with tags attached. Other categories must be unused, unopened, with seals intact and all parts included. Opened, used, or damaged items are not eligible."
    },
    {
      "type": "returnPolicy",
      "title": "30 Days Free Return",
      "description": "30 days easy returns for LazMall products"
    },
    {
      "type": "warranty",
      "title": "Warranty not available",
      "description": "You can still benefit from our return policy if your product does not come with any warranty. Please read the return policy conditions here ."
    }
  ],
  "listed_at": null,
  "position": null,
  "page": null,
  "total_results": null,
  "card_status": "served",
  "detail_status": "served",
  "reviews_status": null,
  "product_id": null,
  "review_text": null,
  "reviewer_name": null,
  "review_date": null,
  "purchase_date": null,
  "variant": null,
  "review_images": null,
  "review_video_url": null,
  "seller_reply": null,
  "helpful_count": null,
  "verified_purchase": null,
  "verdict": null,
  "rows_delivered": null,
  "reviews_delivered": null,
  "note": null,
  "scraped_at": "2026-11-13T19:49:42Z"
}
```

### Pricing

**Pay for the rows a run delivers**, plus one run start; no platform usage and no proxy is billed to you. The row price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Product (`product`) | per 1,000 | $3.99 | $2.99 | $1.99 | $1.99 |
| Review (`review`) | per 1,000 | $3.99 | $2.99 | $1.99 | $1.99 |
| Run start (`start`) | per run | $0.013945 | $0.013945 | $0.013945 | $0.013945 |

A product row is **$3.99 per 1,000** on the Free plan ($0.00399 a row) and $2.99 on Starter, with or without `includeDetails`: every variant with its price and stock, the specifications, the description, delivery and warranty come at no extra event, and a product link always has them. A review row (`includeReviews`) is the same price. Each run that delivers a charged row also pays the **run start, $0.013945 once**; a run that delivers none pays nothing at all. So 50 products cost $0.213445 on the Free plan and $0.163445 on Starter; 1,000 cost $4.003945 and $3.003945; every input of a run shares one start. Never charged: every input's own row (the verdict and Lazada's own count), an item the marketplace does not have, a keyword Lazada finds nothing relevant for, an unknown category or store link, a value that names nothing, a list still refused after 40 fresh connections, a product another input of the run already delivered, a row your filters leave out, and an input left unread at `maxItems`, your charge limit or the time limit. A run that stops early (a timeout, an abort) is charged for the rows it delivered.

Before the first request the log names the prices at your plan and the most the run can cost: each keyword, search, category or store link up to `maxItemsPerInput` (100 by default), each product link one row, `maxItems` over the whole run, `maxReviewsPerProduct` reviews a product, and never more than your charge limit. A Lazada search or category shows one connection's view of its count (1,459 to about 2,000 items on stage 4's walks of 2026-11-13; the list wraps after that), so a higher `maxItemsPerInput` reads that whole view and its input row names Lazada's own count. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **Keywords, links and ids** — `searchKeywords` takes words, one search each, on the marketplace of `country` (sg by default). `startUrls` takes any Lazada link of the six marketplaces — a search (`/catalog/?q=…`, its own `price`, `rating`, `sort`, `service` and `location` filters kept), a category (`/shop-wireless-earbuds/`), a product (`/products/…-i3049365543.html`, the SKU suffix too) or a store (`/shop/anker-official-shop/`) — and bare item ids on `country`'s marketplace. A link inside a redirector (`?u=`, `?url=`) is read too.
- **How far a list goes** — `maxItemsPerInput` (default 100) stops each keyword, search link, category or store; `maxItems` caps the product rows of the whole run. A Lazada search or category shows one connection's view of its count, 1,459 to about 2,000 distinct items in that connection's own order, and then repeats itself: a walk keeps one connection while it is served and ends three pages after the last new item, or at Lazada's own end flag; its row says TRUNCATED with Lazada's count (33,311 for `wireless earbuds` on 2026-11-13). A store is read to its own product count (COMPLETE).
- **Details, reviews and filters** — `includeDetails` reads each product's own page data (one more call a product): every variant with its price and stock, specifications, description, delivery options, warranty, vouchers, the rating histogram and the seller's ratings. A product link always gets it. `includeReviews` adds up to `maxReviewsPerProduct` review rows a product. `sort`, `minPrice`, `maxPrice`, `minRating`, `lazMallOnly` and `flashSaleOnly` are Lazada's own filters, sent with the search and checked on every row; `shipsFrom` is matched against the list's own location names and checked on every row's `ships_from`; `freeShippingOnly` is checked on the card's badge (Lazada's own free-shipping filter does not narrow its list). With `includeDetails` the filters are checked again on the product page's own price. A pasted link's own filter is kept where the input sets none of its kind; where both set one, the input's wins and the input's row says so. A product a filter leaves out is never charged.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `searchKeywords` | `array` | `[]` | Words to search on the marketplace chosen in Country, one search per line (for example: wireless earbuds). Each search reads up to 'Max products per input' rows. Lazada shows one connection's view of a search, 1,459 to about 2,000 items, in its own order. A Lazada link here is read as a link. |
| `startUrls` | `array` | `[]` | Lazada links of any of the six marketplaces: a search (https://www.lazada.sg/catalog/?q=earbuds, its own price, rating, sort and service filters kept), a category (https://www.lazada.sg/shop-wireless-earbuds/), a product (https://www.lazada.sg/products/...-i3049365543.html) or a store (https://www.lazada.sg/shop/anker-official-shop/). A bare item id (3049365543) is read on the marketplace chosen in Country. A product link always returns its full detail. |
| `country` | `sg` / `my` / `ph` / `th` / `vn` / `id` | `"sg"` | The marketplace a keyword or a bare item id is read on. A link keeps its own marketplace. The row's currency is the marketplace's (SGD, MYR, PHP, THB, VND, IDR). |
| `maxItemsPerInput` | `integer` | `100` | The most product rows of each keyword, search link, category or store. A search shows about 2,000 items; a store lists its whole catalogue. |
| `includeDetails` | `boolean` | `false` | Read each product's own page data too: every variant (SKU) with its price and stock, the specifications, the description, delivery options, warranty, vouchers, the category path, the rating histogram and the seller's rating. Slower: one more call a product. Product links always get it. |
| `includeReviews` | `boolean` | `false` | Add each product's reviews as rows of their own (rating, text, variant bought, dates, photos, seller reply, helpful count). Each review is charged as a review row. |
| `maxReviewsPerProduct` | `integer` | `20` | The most review rows of each product, in Lazada's own order (not by date). Used only with 'Include reviews'. |
| `sort` | `popularity` / `priceasc` / `pricedesc` / `best` | `"popularity"` | The order of a keyword's or a category's list, as Lazada's own sort bar offers it. |
| `minPrice` | `integer` |  | Only products at or above this price, in the marketplace's currency. Sent to Lazada for keywords and categories and checked on every row. |
| `maxPrice` | `integer` |  | Only products at or below this price, in the marketplace's currency. |
| `minRating` | `integer` |  | Only products rated at least this many stars (1-5); a product with no rating yet is left out. |
| `lazMallOnly` | `boolean` | `false` | Only products from LazMall (official brand) stores. |
| `flashSaleOnly` | `boolean` | `false` | Only products in a running LazFlash sale. |
| `freeShippingOnly` | `boolean` | `false` | Only products whose card shows the free-shipping badge (Lazada's own free-shipping filter does not narrow its list, so the rows are checked here; a product left out is never charged). |
| `shipsFrom` | `string` |  | Only products shipped from this place, as the list's own 'Location' filter names it (for example: China, Singapore, Overseas). A name the list does not offer gives a free row that lists the names it does offer. |
| `maxItems` | `integer` | `0` | The most product rows of the whole run; 0 = no cap beyond your charge limit. |
| `feedback` | `string` |  | A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A value that is not a Lazada link of the six marketplaces or an item id (another shop's link, a keyword typed into `startUrls`) is not an error: it gets one free `target` row with `status` invalid_input that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

A target row's `status` is `ok` (rows served; its `verdict` says COMPLETE, TRUNCATED, CAPPED or PARTIAL), `not_found` (the marketplace answered that it has no such item, store or category; checked on two connections), `no_results` (the search lists nothing, Lazada marks it as finding nothing relevant, or none of the items on its first page names a word of the keyword), `invalid_input` (not a Lazada link or id, or a `shipsFrom` name the list does not offer), `refused` (still refused after 40 fresh connections), `failed` or `not_read` (left at `maxItems`, the charge limit or the run's time limit). All are free.

**Does it need a Lazada account, cookies or an API key?**

No. Everything is read from what Lazada shows a visitor who is not logged in.

**Is `stock` the real stock?**

Lazada caps each variant's order quantity per marketplace (Singapore 50, Vietnam 10, Indonesia 20; Thailand showed 18 and 30, so no cap is assumed there) and shows the lower of that cap and the stock left. Under the cap the number is the stock (`stock`); at the cap the row says `stock_at_least` with the cap, and so does a product whose every variant shows one and the same number (the seller's purchase limit). Measured over 296 variants on 2026-11-13; one variant's number fell from 18 to 15 in 74 minutes while the others held.

**Why are some texts of a detailed row in Thai or Vietnamese?**

The search lists are asked in English. The product page's own data call answers in the marketplace's language for the seller's texts (category names, specifications, delivery names); the numbers are the same.

**Do I need Apify Proxy or my own proxy?**

No. The Actor uses its own connections, at no extra cost to you.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/lazada-product-scraper').call({"searchKeywords": ["wireless earbuds"], "maxItemsPerInput": 50});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/lazada-product-scraper').call(run_input={'searchKeywords': ['wireless earbuds'], 'maxItemsPerInput': 50})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/lazada-product-scraper --input '{"searchKeywords": ["wireless earbuds"], "maxItemsPerInput": 50}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~lazada-product-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"searchKeywords": ["wireless earbuds"], "maxItemsPerInput": 50}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/lazada-product-scraper` and ask, for example: "Get the Lazada Singapore products for wireless earbuds with price, discount, rating, sold count, seller and stock of every variant". The agent fills the input from the table above and reads the rows from the run's dataset. A field under the name another Actor gives it is read as this Actor's own: `queries`, `keywords`, `searchTerms`, `searchQueries` as `searchKeywords`; `productUrls`, `urls`, `url`, `links` as `startUrls`; `limit`, `maxResults`, `maxProducts`, `resultsLimit` as `maxItemsPerInput`; `enrich_data`, `enrichData`, `enrich`, `includeProductDetails` as `includeDetails` (and more). An agent or a person can add `feedback` to any run and say what was needed and not delivered: a missing field, a wrong or empty result, the Actor switched from or to, and why. The run returns the same rows at the same price, and a person reads every note.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/lazada-product-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[Amazon Product Details Scraper](https://apify.com/hyperbach/amazon-product-details-scraper)** — Amazon products by ASIN, URL or UPC / EAN / ISBN on 21 Amazon stores: the buy-box price, every best-seller rank, the rating and the review summary.
- **[AliExpress Product Details Scraper](https://apify.com/hyperbach/aliexpress-product-details-scraper)** — AliExpress products by URL or item id: every SKU with its own price and stock, in the country and currency you choose.
- **[Shopify Store Scraper](https://apify.com/hyperbach/shopify-products-scraper)** — every product of a Shopify store, with its variants, prices and images.
- **[Alibaba Products Scraper](https://apify.com/hyperbach/alibaba-scraper)** — the products of an Alibaba.com search: price range, minimum order and the supplier with its country and verification.
- **[Walmart Products Scraper](https://apify.com/hyperbach/walmart-scraper)** — Walmart products by search, category or URL: the price with the was-price, the seller and the rating.
- **[Coles Scraper](https://apify.com/hyperbach/coles-scraper)** — Coles Australia products and specials, with the price, the was-price and the unit price.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

## `searchKeywords` (type: `array`):

Words to search on the marketplace chosen in Country, one search per line (for example: wireless earbuds). Each search reads up to 'Max products per input' rows. Lazada shows one connection's view of a search, 1,459 to about 2,000 items, in its own order. A Lazada link here is read as a link.

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

Lazada links of any of the six marketplaces: a search (https://www.lazada.sg/catalog/?q=earbuds, its own price, rating, sort and service filters kept), a category (https://www.lazada.sg/shop-wireless-earbuds/), a product (https://www.lazada.sg/products/...-i3049365543.html) or a store (https://www.lazada.sg/shop/anker-official-shop/). A bare item id (3049365543) is read on the marketplace chosen in Country. A product link always returns its full detail.

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

The marketplace a keyword or a bare item id is read on. A link keeps its own marketplace. The row's currency is the marketplace's (SGD, MYR, PHP, THB, VND, IDR).

## `maxItemsPerInput` (type: `integer`):

The most product rows of each keyword, search link, category or store. A search shows about 2,000 items; a store lists its whole catalogue.

## `includeDetails` (type: `boolean`):

Read each product's own page data too: every variant (SKU) with its price and stock, the specifications, the description, delivery options, warranty, vouchers, the category path, the rating histogram and the seller's rating. Slower: one more call a product. Product links always get it.

## `includeReviews` (type: `boolean`):

Add each product's reviews as rows of their own (rating, text, variant bought, dates, photos, seller reply, helpful count). Each review is charged as a review row.

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

The most review rows of each product, in Lazada's own order (not by date). Used only with 'Include reviews'.

## `sort` (type: `string`):

The order of a keyword's or a category's list, as Lazada's own sort bar offers it.

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

Only products at or above this price, in the marketplace's currency. Sent to Lazada for keywords and categories and checked on every row.

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

Only products at or below this price, in the marketplace's currency.

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

Only products rated at least this many stars (1-5); a product with no rating yet is left out.

## `lazMallOnly` (type: `boolean`):

Only products from LazMall (official brand) stores.

## `flashSaleOnly` (type: `boolean`):

Only products in a running LazFlash sale.

## `freeShippingOnly` (type: `boolean`):

Only products whose card shows the free-shipping badge (Lazada's own free-shipping filter does not narrow its list, so the rows are checked here; a product left out is never charged).

## `shipsFrom` (type: `string`):

Only products shipped from this place, as the list's own 'Location' filter names it (for example: China, Singapore, Overseas). A name the list does not offer gives a free row that lists the names it does offer.

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

The most product rows of the whole run; 0 = no cap beyond your charge limit.

## `feedback` (type: `string`):

A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note.

## Actor input object example

```json
{
  "searchKeywords": [
    "wireless earbuds"
  ],
  "startUrls": [],
  "country": "sg",
  "maxItemsPerInput": 50,
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "sort": "popularity",
  "lazMallOnly": false,
  "flashSaleOnly": false,
  "freeShippingOnly": false,
  "maxItems": 0
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per product (and per review when asked, and one free summary row per input):

## `runSummary` (type: `string`):

How the run went: product and review rows charged, free rows, inputs by status, each input's walk (rows delivered, items listed, pages, the verdict, the source's count), the source counters (calls, served, refused by the slider, exits, rotations, bytes, the slowest answer per route) and the memory watch.

# 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 = {
    "searchKeywords": [
        "wireless earbuds"
    ],
    "maxItemsPerInput": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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 = {
    "searchKeywords": ["wireless earbuds"],
    "maxItemsPerInput": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/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 '{
  "searchKeywords": [
    "wireless earbuds"
  ],
  "maxItemsPerInput": 50
}' |
apify call hyperbach/lazada-product-scraper --silent --output-dataset

```

## MCP server setup

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