# Lazada Scraper (`automation-lab/lazada-products-scraper`) Actor

Extract Lazada products, prices, sellers, ratings, and review counts across six Southeast Asian country storefronts.

- **URL**: https://apify.com/automation-lab/lazada-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Lazada Scraper

Extract structured Lazada product search results from the public Malaysia, Singapore, Indonesia, Philippines, Thailand, and Vietnam storefronts. The Actor returns product names, current prices, seller details, rating and review counts, brand, location, availability, and canonical URLs for repeatable marketplace monitoring.

Use it for one-time catalog research or schedule the same input to track assortment, price, seller, and review-count changes over time. Individual review text is not included.

### What can Lazada Scraper do?

- Search one or more product queries across six Southeast Asian Lazada storefronts.
- Accept a public Lazada `/catalog/` search URL when you already have a precise search.
- Paginate through search results while respecting a global `maxItems` limit.
- Filter products by minimum rating or exact seller name.
- Include or exclude sponsored placements.
- Deduplicate products within a run by country and Lazada item ID.
- Produce clean JSON, CSV, Excel, XML, or RSS exports through Apify datasets.

The Actor reads Lazada’s public catalog response through a sticky Apify datacenter proxy session. It does not require a Lazada account, cookies, or a browser.

### Who is it for?

**Marketplace analysts** can compare assortment and seller coverage across Lazada Malaysia, Singapore, Indonesia, Philippines, Thailand, and Vietnam.

**Pricing teams** can schedule recurring runs and join records by `country` plus `itemId` to identify price or discount changes.

**Brands and distributors** can monitor whether products appear in search, which sellers offer them, and how ratings and review counts evolve.

**Data engineers** can feed typed product records into a warehouse, spreadsheet, dashboard, or alerting workflow without maintaining a country-specific scraper.

### What Lazada data is extracted?

| Field | Meaning |
| --- | --- |
| `country` | Lazada storefront code: MY, SG, ID, PH, TH, or VN |
| `query` | Search phrase associated with the result |
| `position` | Organic or sponsored position across paginated results |
| `itemId`, `skuId`, `sku` | Stable Lazada identifiers when supplied by the catalog |
| `name`, `productUrl`, `imageUrl` | Product identity and links |
| `price`, `priceText`, `originalPrice`, `discount` | Current and former price information |
| `currency` | Storefront currency symbol or code returned by Lazada |
| `rating`, `reviewCount` | Aggregate rating and number of reviews |
| `sellerName`, `sellerId` | Seller identity shown in search |
| `brandName`, `brandId` | Brand identity when available |
| `location` | Seller or fulfillment location shown by Lazada |
| `soldText` | Source-provided sales label, such as `22 sold` |
| `inStock` | Availability when Lazada supplies it |
| `sponsored` | Whether the placement is sponsored |
| `categoryIds` | Lazada category identifiers |
| `sourceUrl`, `scrapedAt` | Exact catalog request and extraction timestamp |

Nullable fields remain `null` when Lazada does not provide them. The Actor does not invent missing prices, brands, availability, or ratings.

### How to scrape Lazada products

1. Open the Actor in Apify Console.
2. Add one or more product phrases to **Search queries**.
3. Select the country storefronts you need.
4. Set **Maximum products** and optional filters.
5. Click **Start**.
6. Open the default dataset to inspect or export the results.

A small first run is useful for checking terminology. For recurring monitoring, keep the same queries, countries, and filters so records remain comparable.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | string\[] | `[]` | Product searches run on every selected country |
| `startUrls` | request\[] | `[]` | Public Lazada country `/catalog/` URLs containing a `q` parameter |
| `countries` | enum\[] | `["MY"]` | Storefronts used for `queries` |
| `maxItems` | integer | `100` | Global maximum unique products, from 1 to 10,000 |
| `maxPagesPerQuery` | integer | `5` | Maximum pages for each query-country job, from 1 to 100 |
| `minRating` | number | none | Keep records with a rating at or above 0–5 |
| `sellerNames` | string\[] | `[]` | Exact seller-name filter, case-insensitive |
| `includeSponsored` | boolean | `false` | Include sponsored placements |

Provide at least one `queries` or `startUrls` value. A start URL determines its country from the hostname; the `countries` input applies only to query jobs.

#### Search across multiple countries

```json
{
  "queries": ["wireless mouse", "laptop stand"],
  "countries": ["MY", "SG", "PH"],
  "maxItems": 100,
  "maxPagesPerQuery": 3,
  "includeSponsored": false
}
```

#### Use an exact Lazada catalog URL

```json
{
  "startUrls": [
    { "url": "https://www.lazada.sg/catalog/?q=mechanical%20keyboard" }
  ],
  "maxItems": 20
}
```

#### Monitor highly rated products

```json
{
  "queries": ["sunscreen"],
  "countries": ["MY", "SG", "PH"],
  "minRating": 4.5,
  "maxItems": 60,
  "maxPagesPerQuery": 5
}
```

### Output example

The default dataset contains one object per accepted product. This abbreviated record comes from a real Singapore search:

```json
{
  "type": "product",
  "country": "SG",
  "query": "mechanical keyboard",
  "position": 1,
  "itemId": "13768908283",
  "productUrl": "https://www.lazada.sg/products/pdp-i13768908283.html",
  "name": "DIANSHIFANG | Stress Relief Mini Mechanical Keyboard Toy",
  "price": 4.92,
  "priceText": "$4.92",
  "currency": "$",
  "rating": 5,
  "reviewCount": 5,
  "sellerName": "Dianshifang Flagship Store",
  "brandName": "DIANSHIFANG",
  "location": "China",
  "soldText": "22 sold",
  "inStock": true,
  "sponsored": false,
  "sourceUrl": "https://www.lazada.sg/catalog/?q=mechanical+keyboard&ajax=true&page=1",
  "scrapedAt": "2026-07-29T02:09:09.895Z"
}
```

Search ordering and product data change continuously, so later runs may return different records.

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

Lazada Scraper uses pay-per-event pricing: one **Start** charge per run plus one **Item processed** charge for each product saved. Filtered, duplicate, malformed, or failed products are not charged as items.

The Start price is **$0.00005**. At the BRONZE tier, each saved product is **$0.002396**. The per-item price decreases on higher Apify plan tiers; Console displays the applicable active price before each run.

| Saved products | BRONZE cost formula |
| ---: | --- |
| 10 | Start price + 10 × item price |
| 100 | Start price + 100 × item price |
| 1,000 | Start price + 1,000 × item price |

Runtime, storage, and the default datacenter proxy route are handled within the Actor’s pay-per-event model. The Actor has no automatic residential proxy or browser fallback, so it does not silently introduce an unmeasured premium route.

### Recurring Lazada price and review monitoring

Create an Apify schedule with a stable input, then compare each dataset snapshot by `country:itemId`.

Useful change signals include:

- product first seen or no longer returned;
- `price` or `originalPrice` changed;
- `sellerName` changed;
- `rating` changed;
- `reviewCount` increased;
- `inStock` changed;
- search `position` moved.

For consistent snapshots, avoid changing countries, filters, or query spelling between runs. Lazada search results can still vary because of source-side ranking and inventory changes.

### Export to spreadsheets and data pipelines

Every run writes to the default Apify dataset. From the dataset page, export JSON, CSV, Excel, XML, or RSS.

You can also connect runs to:

- Google Sheets for lightweight assortment tracking;
- Make or Zapier for alerts and routing;
- webhooks for run-completed automation;
- a data warehouse for longitudinal price analysis;
- Python, JavaScript, or BI tools through the Apify API.

Use `itemId` together with `country` as the primary comparison key. The same numeric item ID should not be assumed globally unique across storefronts.

### Run Lazada Scraper with the API

Replace `YOUR_TOKEN` with an Apify API token. Keep tokens in environment variables or secret storage rather than source code.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~lazada-products-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["wireless mouse"],"countries":["MY"],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/lazada-products-scraper').call({
    queries: ['wireless mouse'],
    countries: ['MY', 'SG'],
    maxItems: 40,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/lazada-products-scraper').call(run_input={
    'queries': ['wireless mouse'],
    'countries': ['MY', 'SG'],
    'maxItems': 40,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

For asynchronous applications, start a run without waiting and consume the dataset after a webhook reports completion.

### Use Lazada Scraper through MCP

Add the Apify MCP server to Claude Code:

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

#### Claude Desktop setup

Add this remote MCP server configuration:

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

#### Cursor setup

Add the same JSON under **Settings → Tools & MCP**, then enable the `apify` server.

#### VS Code setup

Add the same remote server URL to your workspace MCP configuration and start the `apify` server from the MCP panel.

Example prompts:

- “Run Lazada Scraper for `wireless mouse` in Malaysia and Singapore, maximum 40 products.”
- “Extract highly rated sunscreen products from Lazada Philippines and return a CSV-ready table.”
- “Compare this run’s prices and review counts with my previous Lazada dataset.”

MCP can start the Actor and retrieve run output; cross-run comparisons depend on the datasets you provide to the client.

### Reliability and retries

The Actor retries network timeouts, HTTP 429 responses, and temporary server errors up to three times with bounded backoff. It does not repeatedly retry invalid URLs, stable source errors, or recognizable challenge pages without changing the route.

A successful request must return Lazada’s expected JSON catalog shape. HTML, challenge pages, or unexpected JSON fail the run instead of being reported as an empty result.

Results are pushed and charged one at a time after normalization and filtering. The global item limit stops additional pagination as soon as enough useful unique records have been saved.

### Limits and source behavior

- Only public `/catalog/` search responses are supported.
- Product-detail pages and individual review bodies are not scraped.
- `reviewCount` and `rating` are aggregate metrics from search results.
- Search ranking, availability, and prices may be personalized or changed by Lazada.
- Some fields can be absent for a particular item or country.
- Seller-name filtering is exact and case-insensitive.
- `maxItems` is global across all query-country jobs, processed in input order.
- The Actor uses sticky Apify datacenter proxy sessions and has no automatic residential or browser fallback.
- A source challenge causes a clear failed run rather than incomplete silent output.

### Tips for better results

- Use the product wording common on the selected country storefront.
- Run separate inputs when each country needs an independent item quota.
- Keep `includeSponsored` disabled for organic-only monitoring.
- Start with a broad query, inspect seller names, then reuse exact names in `sellerNames`.
- Use stable schedules and retain dataset IDs for historical comparison.
- Prefer smaller, focused queries over one ambiguous phrase when building alerts.

### Legality and responsible use

Lazada Scraper accesses public catalog information without logging into user accounts. You are responsible for ensuring that your use complies with Lazada’s terms, applicable law, contractual obligations, and data-protection requirements.

Do not use the Actor to collect sensitive personal data, overwhelm the source, impersonate users, or make automated decisions about individuals. Respect intellectual-property rights and apply appropriate retention and access controls to exported datasets.

This documentation is operational guidance, not legal advice.

### Troubleshooting

#### The run says I must provide a query or URL

Add at least one non-empty string to `queries`, or provide a supported Lazada country `/catalog/` URL containing the `q` search parameter.

#### A start URL is unsupported

Use one of the six official hosts and a `/catalog/` path. Product URLs, home pages, and non-Lazada hosts are rejected deliberately.

#### The run returned a challenge-page error

Lazada did not return the expected public catalog JSON through the run’s sticky proxy session. Retry later. The Actor intentionally does not disguise that condition as zero products or activate an unpriced residential/browser fallback.

#### Why are fewer items saved than requested?

The source may exhaust its pages, duplicate items across jobs, or have records removed by sponsored, rating, or seller filters. Item charges apply only to records actually saved.

#### Why is rating null?

New or unrated products may not include a rating. When `minRating` is set, records with no rating are excluded.

### Related Automation Lab actors

- [Shopee Products Scraper](https://apify.com/automation-lab/shopee-products-scraper) for comparable Southeast Asian marketplace catalog monitoring.
- [Shopee Reviews Scraper](https://apify.com/automation-lab/shopee-reviews-scraper) when the required workflow is individual Shopee review extraction rather than Lazada aggregate review metrics.

Related Actors cover different sources and should not be treated as a merged cross-market dataset without normalization.

### FAQ

#### Does Lazada Scraper require a Lazada account?

No. It uses public country-storefront catalog responses.

#### Which Lazada countries are supported?

Malaysia, Singapore, Indonesia, Philippines, Thailand, and Vietnam.

#### Does it scrape Lazada review text?

No. It extracts the aggregate rating and review count shown with each catalog result. Individual review text and reviewer profiles are outside the current scope.

#### Can I monitor prices over time?

Yes. Schedule identical inputs and compare records by `country:itemId`. The Actor provides timestamped snapshots; it does not itself calculate historical changes or send alerts.

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

Yes. Each query is run against each selected country until the global `maxItems` limit is reached.

#### Are filtered products charged?

No. The per-item event is charged only after a unique product passes validation and filters and is about to be saved.

#### Can I use a product URL as input?

No. `startUrls` accepts catalog search URLs, not product-detail URLs. Use `queries` when you only know a product phrase.

#### Is complete catalog coverage guaranteed?

No. Output reflects the public result pages available during the run and the configured page and item limits. Lazada can change rankings, fields, availability, and access behavior.

# Actor input Schema

## `queries` (type: `array`):

Product searches to run on each selected Lazada country storefront.

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

Optional Lazada /catalog/ search URLs. The q parameter is required.

## `countries` (type: `array`):

Southeast Asia Lazada storefronts to search for every query.

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

Stop after saving this many unique product records across all searches.

## `maxPagesPerQuery` (type: `integer`):

Maximum catalog pages requested for each query and country combination.

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

Keep only products at or above this Lazada rating.

## `sellerNames` (type: `array`):

Optional exact, case-insensitive seller-name filter.

## `includeSponsored` (type: `boolean`):

Include sponsored catalog placements in the output.

## Actor input object example

```json
{
  "queries": [
    "wireless mouse"
  ],
  "countries": [
    "MY"
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 5,
  "includeSponsored": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Typed Lazada product search records with prices, sellers, ratings, review counts, and source links.

# 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 = {
    "queries": [
        "wireless mouse"
    ],
    "countries": [
        "MY"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/lazada-products-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 = {
    "queries": ["wireless mouse"],
    "countries": ["MY"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/lazada-products-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "wireless mouse"
  ],
  "countries": [
    "MY"
  ],
  "maxItems": 20
}' |
apify call automation-lab/lazada-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/lazada-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/VZ2AEmLDtB6FC7Vdk/builds/OWNHVWVuclB6aGITZ/openapi.json