# Lazada Scraper — Search, Product Data, Prices & Reviews (`lergassy/lazada-scraper`) Actor

Scrape Lazada data from all six Southeast Asian marketplaces: search results, full product pages and reviews. Price, discount, rating, sold count, seller, image gallery and every variant with its own price and stock, plus reviews with photos and seller replies. No login, no API key, no start fee.

- **URL**: https://apify.com/lergassy/lazada-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** E-commerce, Automation, AI
- **Features:** Limited permissions
- **Stats:** 170 total users, 91 monthly users, 99.9% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.40 / 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 Scraper** extracts public **Lazada product data** from all **six Southeast Asian marketplaces** — Indonesia, Malaysia, Singapore, Philippines, Thailand and Vietnam — without the official API and **without running a browser**. Search by keyword or paste a search, category or shop URL to get product cards with price, discount, rating, sold count and seller; give product URLs for the full product detail with description, image gallery and variants, plus customer reviews with photos and seller replies. No login, no API key, no seller account. Export to JSON, CSV or Excel, call it from the API, schedule runs, or plug it into n8n, Make, Zapier, Google Sheets or an AI agent through MCP.

**$2 per 1,000 products** on the Apify free plan — you pay for delivered rows, nothing else. Higher Apify plans pay less, down to $1.4.

### Tested head-to-head — 24 September 2026

![Lazada Scraper tested against the 6 most-used Lazada scrapers: 20 of 20 products, no start fee, $2 per 1,000 products, reviews and full product pages](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/benchmarks/lazada-tested-2026-09-24.png)

Same request for every Actor — 20 products for "wireless earbuds" on Lazada Singapore — run against
the six most-used Lazada scrapers on the Apify Store, from an ordinary paying account.

| | This Actor | The six others |
|---|---|---|
| Products returned (20 asked) | **20** | 20 from five; one failed after 3 minutes with none |
| Start fee per run | **None** | 3 of 6 charge one (up to $0.20 for this run) |
| Price per 1,000 search products vs the most-used one | **$2** | $3.99 |
| Search, full product pages and reviews on all six marketplaces | **Yes** | 3 of 6 |

### What is Lazada Scraper?

Lazada is one of the two dominant marketplaces in Southeast Asia, with separate storefronts, currencies and catalogs in six countries. There is no public product API for buyers, and the product page renders in the browser, so most tooling either misses fields or pays for a headless browser on every request.

This Actor reads Lazada's own data endpoints directly over plain HTTP, with no browser. A product page returns the full description, the complete image gallery, the specifications table, every variant with its own price and stock, delivery options and fees, warranty and return policy, brand, seller and availability; the reviews endpoint returns each review with its star rating, the buyer's photos and the purchased variant. That makes runs fast and cheap: fifty reviews come back in seconds.

**Search gets through Lazada's anti-bot gate.** Since September 2026 Lazada answers most automated search requests with an anti-bot page. This Actor requests with a real Chrome fingerprint and rotates addresses — platform egress, datacenter, residential — until one gets through, then keeps that address for the following pages. The retries are on us: you pay only for the products returned. If the gate still refuses a keyword search on every address, the rest of that search comes from our backup data source — same products and prices, rows marked `listingSource: "paid-api-search"` — instead of an error row. Checked on all six marketplaces on 24 September 2026.

| Mode | What you get | Input |
|---|---|---|
| 🔍 **Products from search** | Product cards: title, price, original price, discount, rating, review count, sold count, brand, seller, location, LazMall and sponsored flags, images, position | keywords, search, category, brand or shop URLs |
| 📦 **Product details** | Full product page: description, highlights, specifications, image gallery, every variant with its own price and stock, delivery fees, warranty, returns, brand, category, availability | product URLs or item IDs |
| ⭐ **Reviews** | Customer reviews: rating, text, variant bought, buyer name, date, helpful votes, photos, seller reply | product URLs or item IDs |
| 📦+⭐ **Products with reviews** | Both of the above for each product in one run | product URLs |

Every row carries `country`, `marketplace`, `currency` and `itemId`, so one dataset can hold several countries at once.

### Supported Lazada marketplaces

| Country | Code | Domain | Currency |
|---|---|---|---|
| 🇮🇩 Indonesia | `ID` | lazada.co.id | IDR |
| 🇲🇾 Malaysia | `MY` | lazada.com.my | MYR |
| 🇸🇬 Singapore | `SG` | lazada.sg | SGD |
| 🇵🇭 Philippines | `PH` | lazada.com.ph | PHP |
| 🇹🇭 Thailand | `TH` | lazada.co.th | THB |
| 🇻🇳 Vietnam | `VN` | lazada.vn | VND |

Prices come back in the marketplace's own currency and are never converted.

### What data can Lazada Scraper extract?

#### 🔍 Product cards

| Field | Example |
|---|---|
| `title` | `iPhone 17 Pro` |
| `price` / `originalPrice` / `discountPercent` | `22414000` / `32000000` / `30` |
| `currency` / `priceText` | `IDR` / `Rp22.414.000` |
| `rating` / `reviewCount` | `4.87` / `62` |
| `soldQuantity` / `soldText` | `220` / `220 sold` |
| `brand` / `brandId` | `Apple` / `127197227` |
| `sellerName` / `sellerId` | `Apple Authorised Reseller` / `402540720932` |
| `location` | `Kota Depok` |
| `isLazMall` / `isSponsored` | `true` / `false` |
| `badges` | `["Voucher save 30%", "Trade In"]` |
| `itemId` / `skuId` | `8737698858` / `16177996790` |
| `inStock` | `true` |
| `url` / `imageUrl` / `images` | product link, main picture, thumbnails |
| `position` / `page` / `keyword` / `totalResults` | `1` / `1` / `iphone 15` / `4080` |

#### 📦 Product details

`description` (the seller's full description as plain text), `descriptionHtml`, `highlights` (the bullet list from the page), `images` (full gallery), `imageCount`, `specs` (the specifications table as `{"name": "Case/Cover Material", "value": "TPU"}` pairs), `variants` with every option combination and its own price and stock (`{"skuId": "19973701508", "values": [{"name": "Color Family", "value": "Clear"}], "price": 11.0, "originalPrice": 23.1, "stock": 999}`), `variantCount`, `inStock`, `boxContent`, `warrantyType`, `warrantyPeriod`, `returnPolicy`, `shipsFrom`, `deliveryOptions` (each with its fee), `sellerPositiveRating`, `brand`, `brandUrl`, `category`, `categoryId`, `availability`, `sku` and `sellerId`.

##### Saved copy (default) or Live data (add-on)

**By default the product record comes from Lazada's own saved copy of the product page.** It is fast (about 2 seconds a product), costs nothing extra, and carries the whole record — specifications, every variant with its price and availability, seller, rating, delivery options. A saved copy is not the live page: Lazada refreshes it on its own schedule, and in our measurements copies were between a few hours and five days old, with the price or availability of some variant differing from the live page on roughly four products in ten. Every such row says so:

| Field | Meaning |
|---|---|
| `dataFreshness` | `saved-copy`, `live` or `recent-cache` |
| `dataAsOf` | when the prices and availability on the row were current (UTC) |
| `dataAgeHours` | how old they were when the row was written |
| `dataNote` | the same in words |

In a search run with product details on, `price`, `rating` and `soldQuantity` still come from the search result itself and are live; the saved copy supplies variants, specifications and delivery.

**Turn on "⚡ Live data" when you need current prices and stock** — price monitoring, repricing, stock checks. The Actor then reads the record at run time through a browser session in the storefront's country and a backup source. It is slower and billed as a separate event per product (`specifications` in the price list), only when live data arrives. `includeSpecifications: true` in older inputs and saved tasks means the same thing and keeps working.

A product whose saved copy Lazada does not serve in full (about one in eight) is read live at no extra charge.

#### ⭐ Reviews

`rating`, `text`, `variant` (the exact option the buyer purchased), `reviewer`, `reviewTime`, `boughtDate`, `verifiedPurchase`, `likes`, `images` (buyer photos), plus `reviewId`, `itemId` and `productUrl`.

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

The Actor uses Apify's **pay-per-event** pricing, so you pay for results, not for pages or proxy traffic.

| Event | Price | Per 1,000 |
|---|---|---|
| Product (search card) | $0.002 | **$2** |
| Product detail (full product record) | $0.00319 | **$3.19** |
| Review | $0.001 | **$1** |
| Live data (optional add-on, on top of the product detail) | $0.0077 | **$7.70** |

**A default run costs what the price tag says.** Out of the box a search returns product cards at $0.002 a row — no hidden extras. Tick **Fetch full product details** to add the full product record ($0.00319 a product): description, gallery, specifications and every variant with its own price and availability, about 46 fields a row. It comes from Lazada's saved copy of the product page, and the row says when the copy was made.

**Live data.** Tick **⚡ Live data** when you need the prices and stock of this very moment ($0.0077 a product on top of the product detail). The Actor then reads them at run time, in a real browser session with an address in the storefront's country and through a backup source. It is billed only when live data actually arrives; rows say which they are in `dataFreshness`.

If Lazada does not let a session in, the Actor tries new addresses in the same country before giving up on that storefront (`STATS.ladder` in the key-value store shows how many it took). Rows from a storefront it could not open carry `specsSource: "page-only"` and a `specsNote`, and are not charged for specifications.

Search, listings and reviews need no browser, so they cost a fraction of a cent of platform usage; a run with specifications opens one browser per country for a minute. The **Apify Free plan** ($5 monthly credit) covers roughly 2,500 product cards, 1,250 full product records or 5,000 reviews every month.

#### Bulk export: what 50,000 products actually cost

This Actor is built for bulk jobs — put hundreds of inputs into one run, or call it from the API on
a schedule. There is **no fee per run, no fee per page and no proxy charge**: you pay for the rows
you keep, and error rows are free. That is what decides the bill once you pull a whole market
rather than a single store.

| Job | This Actor | Most-used Actor in this category |
|---|---|---|
| 50,000 products across 100 runs | **$100** | $199.50 |

Checked on the Apify Store on 24 September 2026 against the Actor with the most monthly users in
this category; its per-run fee is counted in, as ours would be if we charged one. Some Actors here
ask less per row — this table compares against the one buyers actually use most.

### How to scrape Lazada

1. Open **Lazada Scraper** on Apify and click **Try for free**.
2. Choose **What to scrape** — for example *Products from search*.
3. Pick the **Country** (Indonesia by default).
4. Type **Search keywords**, or paste **Lazada URLs**: product links, search results, category, brand or shop pages. Links from different countries can be mixed in one run.
5. Set **Max products**, optionally turn on **Fetch full product details**, then click **Start**.
6. When the run finishes, open the **Output** tab and download JSON, CSV, Excel or XML, or read the dataset through the API.

### ⬇️ Input

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

Search Indonesia for two keywords, cheapest first:

```json
{
  "mode": "search",
  "country": "ID",
  "searchTerms": ["iphone 15", "samsung s24"],
  "sortBy": "price_asc",
  "maxItems": 200
}
```

Full detail for specific products, from any marketplace:

```json
{
  "mode": "product",
  "startUrls": [
    "https://www.lazada.co.id/products/iphone-17-pro-i8737698858.html",
    "https://www.lazada.com.my/products/x-i4567890123.html"
  ]
}
```

All reviews of a product, 5-star only:

```json
{
  "mode": "reviews",
  "startUrls": ["https://www.lazada.co.id/products/iphone-17-pro-i8737698858.html"],
  "maxReviewsPerProduct": 1000,
  "reviewsRating": "5"
}
```

A category page in Thailand and a brand page in Vietnam in one run:

```json
{
  "startUrls": [
    "https://www.lazada.co.th/shop-mobiles/",
    "https://www.lazada.vn/apple/"
  ],
  "maxItems": 100
}
```

#### Search filters

`sortBy` (`relevance`, `price_asc`, `price_desc`, `newest`, `rating`), `minPrice` and `maxPrice` in the marketplace currency, and `minRating` (0–5 stars) to keep only well-rated products. Turn on **Fetch full product details** to open every result's page and merge description, gallery and variants into the row.

### ⬆️ Output

![Lazada Scraper output table: product, price, previous price, discount, rating, units sold, brand, seller, shipping location](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/lazada/lazada-scraper-output-table.png)

One product card:

```json
{
  "type": "product",
  "title": "iPhone 17 Pro",
  "url": "https://www.lazada.co.id/products/pdp-i8737698858.html",
  "itemId": "8737698858",
  "skuId": "16177996790",
  "country": "ID",
  "marketplace": "Indonesia",
  "currency": "IDR",
  "price": 22414000,
  "originalPrice": 32000000,
  "discountPercent": 30,
  "priceText": "Rp22.414.000",
  "rating": 4.87,
  "reviewCount": 62,
  "soldQuantity": 220,
  "brand": "Apple",
  "sellerName": "Apple Authorised Reseller",
  "sellerId": "402540720932",
  "location": "Kota Depok",
  "isLazMall": true,
  "badges": ["Voucher save 30%", "Trade In"],
  "inStock": true,
  "position": 1,
  "keyword": "iphone 15",
  "totalResults": 4080,
  "scrapedAt": "2026-09-03T07:46:24.903Z"
}
```

One product detail (description shortened here):

```json
{
  "type": "product_detail",
  "itemId": "8737698858",
  "title": "iPhone 17 Pro",
  "brand": "Apple",
  "category": "Handphone & Tablet",
  "availability": "InStock",
  "description": "iPhone 17 Pro. Poin-poin fitur utama. DESAIN UNIBODY …",
  "highlights": ["iPhone 17 Pro.", "Layar 6,3 inci yang cemerlang", "Chip A19 Pro"],
  "imageCount": 24,
  "variantCount": 6,
  "variants": [
    { "skuId": "16177996790", "values": [{ "name": "Warna", "value": "Silver" }, { "name": "Kapasitas Penyimpanan", "value": "256 GB" }] }
  ],
  "url": "https://www.lazada.co.id/products/iphone-17-pro-i8737698858.html"
}
```

Rows carry a `type` (`product`, `product_detail`, `review`, `error`), so one dataset can be filtered in a spreadsheet or in code. Pages that fail after the retries are written as `error` rows with the URL and reason instead of disappearing.

### Use cases for Lazada data

#### Price monitoring and repricing

Track `price`, `originalPrice`, `discountPercent` and `soldQuantity` for your listings and competitors on a schedule, and push the dataset to Sheets or your pricing tool.

#### Cross-border market research

Search the same category in Indonesia, Vietnam, Thailand and the Philippines in one run and compare price levels, discount depth and demand between markets.

#### Product research and sourcing

Units sold, ratings and review counts show what actually moves. Product details add the description and every variant, so you can size an assortment before contacting suppliers.

#### Seller and brand intelligence

Cards carry the seller name and ID, the brand and the LazMall flag, so you can map who dominates a category and which brands run the deepest discounts.

#### Review mining

Pull thousands of reviews with star ratings, the exact variant bought, buyer photos and seller replies, then run sentiment analysis or feed them to an LLM for recurring complaints.

#### AI agents and RAG

Flat rows, literal field names and no required inputs make the Actor easy to call from an agent through the Apify MCP server.

### Integrations

- **API** — start a run and read the dataset with any HTTP client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lergassy/lazada-scraper").call(run_input={
    "country": "ID", "searchTerms": ["air fryer"], "maxItems": 100
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["currency"])
```

- **JavaScript** — `npm i apify-client`, then `client.actor('lergassy/lazada-scraper').call(input)`.
- **n8n, Make, Zapier, Google Sheets, Airtable, Slack, webhooks** — through the standard Apify integrations.
- **MCP** — add the Apify MCP server to Claude, ChatGPT or Cursor and let the agent call `lergassy/lazada-scraper` with a keyword and a country.

### Errors and troubleshooting

| What you see | What it means | Fix |
|---|---|---|
| `error` rows with an anti-bot message | Lazada throttled that IP for the listing endpoint | Rare: the Actor already rotated through up to 30 addresses. Re-run in a few minutes |
| Fewer results than **Max products** | The keyword ran out of pages | Use broader or several keywords, or a category URL |
| `soldQuantity` is null | Lazada hides the counter on some listings | Use `soldText` when present, or product details |
| Reviews return nothing | The product has no written reviews yet | Check `reviewCount` on the product card first |
| Product detail without a price | Prices live on the card, not on the page markup | Run search mode, or enable **Fetch full product details** so both are merged |
| Status says **Stopped early** and the key-value store has `NOT_ATTEMPTED` | The run reached its timeout (or Lazada refused 3 pages in a row after every retry) | Nothing was charged for the listed jobs. Raise the run timeout, or re-run them later |

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling this Actor through the [Apify MCP server](https://mcp.apify.com) or the Apify API (`lergassy/lazada-scraper`).

**Purpose:** returns Lazada listings and buyer reviews across six South-East Asian
marketplaces — by search term or by product URL — with price, discount, rating,
units sold, seller and LazMall status. Use it to answer "what does this cost in
Malaysia today", "which sellers dominate this query" and "what do buyers complain
about in these reviews".

**Minimal input:**

```json
{ "searchTerms": ["iphone 15"], "country": "ID", "maxItems": 40 }
```

**Output:** one row per listing — `type`, `itemId`, `title`, `url`, `country`,
`marketplace`, `currency`, `price`, `originalPrice`, `discountPercent`, `rating`,
`reviewCount`, `soldQuantity`, `brand`, `sellerName`, `isLazMall`, `location`,
`imageUrl`, `scrapedAt`. Enriched rows add `category`, `description`, `highlights`,
`variants` and `variantCount`. Review rows carry `rating`, `text`, `variant`,
`reviewer`, `reviewTime`, `likes` and `images`. Unreadable pages
arrive as `type: "error"` rows with `error` and `kind`.

**Behaviors an agent should know:**

- `mode` defaults to `auto`: search terms run search mode, product URLs run product
  mode. Set `reviews` or `product_reviews` explicitly when you want review rows.
- `country` selects the marketplace and the currency. Prices are in the
  marketplace's own currency; never compare across countries without converting.
- `maxItems` (default 40) caps listings; `maxReviewsPerProduct` (default 100) caps
  reviews separately, so a review run's size is the product of the two.
- `reviewsRating` narrows reviews to one star value — use it instead of pulling
  everything and filtering afterwards.
- `enrichProducts` costs an extra page fetch per product; leave it off when listing
  fields suffice.
- Review text is mostly Indonesian, Malay, Thai or Vietnamese depending on the
  marketplace. Translate before sentiment scoring, and expect masked buyer names.
- `isLazMall` marks Lazada's verified-brand tier — a useful proxy for whether a
  listing is from an official store or a marketplace reseller.

### ❓ FAQ

#### Is it legal to scrape Lazada?

The Actor reads only pages and endpoints that any visitor can open without logging in: listings, product pages and public reviews. It does not authenticate, does not touch buyer accounts and collects no private data. You are responsible for using the data in line with local law and Lazada's terms; consult a lawyer for your case.

#### Do I need a Lazada API key or a seller account?

No. Lazada's open API is for sellers and partners. This Actor never authenticates.

#### Does it use a browser?

No. Everything is plain HTTP, which is why runs cost a fraction of a cent.

#### Can I scrape several countries in one run?

Yes. Keyword searches use the selected country, and each URL keeps its own marketplace. Rows record `country`, `marketplace` and `currency`.

#### How many products can one keyword return?

Lazada pages listings in blocks of about 40 and reports the total in `totalResults`. Deep paging on a broad keyword drifts into loosely related items, so several narrow keywords beat one broad one.

#### Can I get per-variant prices and stock?

Yes. Product details return every variant with its option values (e.g. Color: Black, Storage: 128 GB), SKU ID, its own price, original price, availability (`inStock`) and image, on every Apify plan — `specsSource` shows which rows have it.

#### Does it collect buyer questions?

No. Only reviews, which include the variant bought, photos and seller replies where present.

#### Can I use it with the Apify API, MCP or n8n?

Yes, see Integrations. The input is plain JSON and `startUrls` accepts product, search, category, brand and shop links.

### Run health

When a run ends with many error rows, the Actor sends its developer the counts (rows delivered, error types, run ID) so the cause gets fixed fast; your input and results are never sent.

### Your feedback

Missing a field, a country or a page type? Open an issue in the **Issues** tab or leave a review — user requests decide what ships next.

### You might also like

| Actor | What it does |
|---|---|
| [Shopee Scraper](https://apify.com/lergassy/shopee-scraper) | Products, prices and sellers across 11 Shopee marketplaces |
| [Tokopedia Reviews Scraper](https://apify.com/lergassy/tokopedia-reviews-scraper) | Shop reviews from Indonesia's Tokopedia |
| Mercado Libre Scraper | Products, prices, reviews and deals across 18 Latin American marketplaces |
| [Google Flights Scraper](https://apify.com/lergassy/google-flights-scraper) | Flight prices, airlines and price insights |
| [Email Verifier & Phone Number Validator](https://apify.com/lergassy/email-phone-verifier) | Checks e-mails and phone numbers in bulk: deliverability, throwaway and role flags, numbering plan, US state and time zone |

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/lazada-scraper/changelog.md

# Actor input Schema

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

What to scrape. **Auto** runs search for keywords and search/category/shop URLs, and product details for product URLs. 🔍 Search returns product cards; 📦 Product details and ⭐ Reviews need product URLs.

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

Lazada marketplace for keyword searches. URLs keep their own country.

## `searchTerms` (type: `array`):

Keywords to search on the chosen marketplace, e.g. `wireless earbuds`. Each keyword returns product cards with price, discount, rating, sold count and seller, up to 🔢 Max products.

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

Any Lazada links: product pages (<code>.../products/...-i123456.html</code>), search results, category, brand or shop pages. Bare item IDs also work. Product page URLs (`.../products/pdp-i<id>.html`) are the reliable input right now.

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

Stop after this many products per keyword or listing URL.

## `enrichProducts` (type: `boolean`):

Add the full product record to every search result: description, image gallery, specifications, every variant with its price and availability, seller and delivery options. Billed per product detail ($0.00319 on the Free plan). The record comes from Lazada's saved copy of the product page unless "Live data" below is on. Off by default, so a search run costs exactly the $2 per 1,000 products on the price tag.

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

Off (default): product details — specifications, every variant's price and availability, seller, delivery options — come from Lazada's own saved copy of the product page. Fast, no extra charge, and every row says when the copy was made (`dataAsOf`; usually hours to a few days old). On: the same data is read live at run time through a browser session in the storefront's country — slower, billed as a separate event per product (`specifications`), only when live data arrives. Turn it on for price monitoring and stock checks.

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

Reviews mode: how many reviews to collect for each product.

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

Reviews mode: keep only reviews with this star rating.

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

Order of search results.

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

Minimum price in the marketplace's own currency.

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

Maximum price in the marketplace's own currency.

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

Keep only products rated at least this (0–5 stars). Applied to the rating shown on the card; products without a rating are dropped when this is set.

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

Lazada answers most automated requests with an anti-bot page. The Actor rotates by itself — platform egress, datacenter, then residential — and keeps the address that got through. Leave as is unless you have your own proxy URLs.

## Actor input object example

```json
{
  "mode": "auto",
  "country": "ID",
  "searchTerms": [
    "iphone 15"
  ],
  "startUrls": [],
  "maxItems": 10,
  "enrichProducts": false,
  "liveData": false,
  "maxReviewsPerProduct": 100,
  "reviewsRating": "all",
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

One row per Lazada listing with price, discount, rating, units sold, brand, seller and LazMall status; enriched rows add description, highlights and variants; review rows carry the buyer's stars, text, photos and the seller's reply.

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

JSON counters for the run: rows delivered, filtered out, errors and request statistics.

## `notAttempted` (type: `string`):

JSON list of inputs the run did not reach (time limit or "Max cost per run"). Not charged — pass them as input to a new run to continue. Present only when the run stopped early.

# 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 = {
    "country": "ID",
    "searchTerms": [
        "iphone 15"
    ],
    "startUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/lazada-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 = {
    "country": "ID",
    "searchTerms": ["iphone 15"],
    "startUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/lazada-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 '{
  "country": "ID",
  "searchTerms": [
    "iphone 15"
  ],
  "startUrls": [],
  "maxItems": 10
}' |
apify call lergassy/lazada-scraper --silent --output-dataset

```

## MCP server setup

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