# Lazada Scraper — Prices, Ratings & Seller Data (`khadinakbar/lazada-scraper`) Actor

Scrape Lazada products across all 6 SEA venues (SG/MY/ID/PH/TH/VN) by keyword search, category URL, or product URL — price, discount, rating, reviews, sold count, seller, brand, image. HTTP-only, no login. MCP-ready.

- **URL**: https://apify.com/khadinakbar/lazada-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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 — Prices, Ratings & Seller Data

Lazada Scraper is an Apify Actor for collecting Lazada product records across all six Southeast Asia venues: Singapore, Malaysia, Indonesia, Philippines, Thailand, and Vietnam. It accepts a keyword search, a category or shop URL, or a product URL, auto-detects the mode, and returns one dataset record per product. The returned fields can include name, price, discount, rating, reviews, sold count, seller, brand, image, venue, and provenance fields such as `sourceUrl` and `scrapedAt`. The Actor is HTTP-only, uses no login, and is usable through Apify MCP.

### Best fit and connected workflows

This Actor fits workflows that start with Lazada product discovery or a pasted Lazada page and need structured product data from a specific venue.

Typical routing patterns:

- Keyword-based catalog discovery on one Lazada venue using `search` plus `country`.
- Category or shop listing collection using `startUrls` for broader assortment pulls.
- Product URL enrichment for resolving a single Lazada product page into a structured record.
- Apify MCP agent workflows where one tool call returns product records for downstream comparison, cataloging, or enrichment.

If your starting point is a venue-specific search term, use `search` with `country`. If your starting point is a Lazada URL, use `startUrls` and let the Actor detect the page type.

### Practical scenario

Maya is reviewing wireless earbuds on Lazada Singapore. She starts with the keyword `wireless earbuds` and sets `country` to `sg`. The dataset returns fields such as `name`, `price`, `ratingScore`, `reviewCount`, `soldCount`, `sellerName`, and `url`. Maya uses `ratingScore` and `reviewCount` to shortlist products, then opens the `url` of the strongest candidates and shares the structured records with her team.

### Input fields

| Field | Type | Description |
|---|---|---|
| `search` | string | Free-text keyword to search on Lazada. Use this for result-grid searches. Leave empty when using `startUrls`. |
| `country` | string | Lazada venue for keyword search: `sg`, `my`, `id`, `ph`, `th`, or `vn`. Defaults to `sg`. |
| `startUrls` | array | Lazada URLs to scrape. Supports product pages, category or shop pages, and search-result URLs. |
| `maxResults` | integer | Maximum number of products to return across all searches and URLs combined. |
| `maxPagesPerList` | integer | Maximum pages to paginate through for each keyword search or category URL. |
| `proxyConfiguration` | object | Proxy settings for requests. |

#### Focused JSON example

```json
{
  "search": "robot vacuum",
  "country": "sg",
  "maxResults": 50,
  "maxPagesPerList": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output fields

The dataset contains one record per scraped product. Search and category flows usually produce `listing` records. Product URLs produce `detail` records.

| Field | Type | Description |
|---|---|---|
| `type` | string | Record kind: `listing` or `detail`. |
| `itemId` | string | Lazada numeric product id. |
| `skuId` | string | Lazada SKU id when present. |
| `name` | string | Product title. |
| `url` | string | Canonical product URL. |
| `brand` | string | Brand name when exposed. |
| `price` | string | Formatted current price with currency. |
| `priceValue` | number | Numeric current price in venue currency. |
| `originalPrice` | string | Formatted pre-discount price when on promo. |
| `discount` | string | Discount label. |
| `currency` | string | ISO currency code for the venue. |
| `ratingScore` | number | Average star rating from 0 to 5. |
| `reviewCount` | integer | Number of reviews or ratings. |
| `soldCount` | string | Sold-count label when exposed. |
| `sellerName` | string | Seller or shop name. |
| `sellerId` | string | Seller id when exposed. |
| `location` | string | Seller or ship-from location. |
| `inStock` | boolean | Reported stock status. |
| `category` | string | Product category in detail mode. |
| `description` | string | Product description snippet in detail mode. |
| `breadcrumbs` | array | Category breadcrumb trail in detail mode. |
| `imageUrl` | string | Primary product image URL. |
| `isAd` | boolean | True when the card was a sponsored placement. |
| `venue` | string | Lazada venue code: `sg`, `my`, `id`, `ph`, `th`, or `vn`. |
| `sourceUrl` | string | The input or page URL scraped for this record. |
| `scrapedAt` | string | ISO 8601 timestamp of the scrape. |

#### Illustrative output record

```json
{
  "type": "listing",
  "itemId": "1234567890",
  "skuId": "9876543210",
  "name": "Wireless Earbuds Pro",
  "url": "https://www.lazada.sg/products/sample-i1234567890-s9876543210.html",
  "brand": "Example Brand",
  "price": "S$29.90",
  "priceValue": 29.9,
  "originalPrice": "S$59.90",
  "discount": "-50%",
  "currency": "SGD",
  "ratingScore": 4.7,
  "reviewCount": 1245,
  "soldCount": "2K sold",
  "sellerName": "Example Shop",
  "sellerId": "seller-123",
  "location": "Singapore",
  "inStock": true,
  "category": "Audio",
  "description": "Wireless earbuds with charging case.",
  "breadcrumbs": ["Electronics", "Audio", "Earphones"],
  "imageUrl": "https://example.com/image.jpg",
  "isAd": false,
  "venue": "sg",
  "sourceUrl": "https://www.lazada.sg/catalog/?q=wireless+earbuds",
  "scrapedAt": "2026-06-24T12:34:56.000Z"
}
```

### How it works

This Actor uses HTTP requests only and auto-detects the mode from the input. Keyword and category or shop URLs are collected through Lazada's AJAX JSON endpoint, which returns listing data with price, rating, sold count, and seller information. Product URLs are resolved from page metadata, including JSON-LD details where available. Pagination is handled automatically for listing flows, and product records are deduplicated across pages. The Actor uses country-pinned residential proxies for the target venue.

### Pricing

This Actor uses Pay per event plus Apify platform usage. The primary charged event is `Product`, billed for each product returned. The Actor also includes an `Actor start` event charged once per run based on allotted memory. See the live Pricing tab in Apify for the current billing view.

For example, a run that returns one hundred products charges one hundred `Product` events.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as an Apify Actor tool. The exact Actor identity is `khadinakbar/lazada-scraper`. It accepts a Lazada keyword or URL and returns structured product records that an agent can read, compare, and pass into downstream workflows.

> Search Lazada Singapore for "robot vacuum" and return up to 20 product records with price, rating, review count, sold count, seller, venue, and product URL. Use the dataset output for comparison and summarize the strongest options by the returned fields.

Output interpretation is straightforward: `listing` records represent search or category cards, while `detail` records represent product pages. Provenance is captured in `sourceUrl` and `scrapedAt`, and venue scope is captured in `venue`. For pagination, increase `maxPagesPerList` to move deeper through search or category pages. Cost guidance follows the returned product count, since each returned product triggers a `Product` event.

### Apify API example

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const input = {
    search: 'robot vacuum',
    country: 'sg',
    maxResults: 20,
    maxPagesPerList: 2,
    proxyConfiguration: {
        useApifyProxy: true,
        apifyProxyGroups: ['RESIDENTIAL'],
    },
};

const run = await client.actor('khadinakbar/lazada-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Best results and outcome guidance

Use `search` when you want a venue-specific product grid for a keyword, and use `startUrls` when you already have a Lazada page to extract. Set `country` only for keyword searches, since URLs carry their own venue. Increase `maxPagesPerList` when a listing workflow should collect more pages, and use `maxResults` to cap the total number of returned products across all inputs.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow.

### Design note

I found that the dataset schema clearly separates `listing` and `detail` records, which makes it useful to treat search or category pages and product pages as two related but distinct output shapes.

### FAQ

**Which Lazada venues can this Actor handle?**\
It supports Singapore, Malaysia, Indonesia, Philippines, Thailand, and Vietnam.

**When should I use `search` instead of `startUrls`?**\
Use `search` for keyword discovery on a chosen venue. Use `startUrls` when you already have a Lazada product, category, shop, or search-result URL.

**What fields are most useful for product comparison?**\
Common comparison fields are `price`, `ratingScore`, `reviewCount`, `soldCount`, `sellerName`, `brand`, and `url`.

**Can this Actor be used with Apify MCP?**\
Yes. It is an Apify Actor that is usable through Apify MCP.

**How do I read the venue from the output?**\
Use the `venue` field, which returns `sg`, `my`, `id`, `ph`, `th`, or `vn`.

### Responsible use

This Actor collects publicly available Lazada product information. Use the data in ways that align with Lazada's terms, applicable laws, and your own compliance requirements. Respect privacy, intellectual property, and platform rules when storing, sharing, or automating actions from the returned dataset.

# Actor input Schema

## `search` (type: `string`):

Free-text keyword to search on Lazada (e.g. 'wireless earbuds'). The actor runs the search on the venue chosen in 'country' and returns the result grid. Leave empty if you are instead pasting Lazada URLs into 'startUrls'. NOT a URL — for a specific product or category page use 'startUrls'.

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

Which Lazada country site to run the keyword search on. Only applies to 'search'; URLs in 'startUrls' carry their own venue. One of: sg (Singapore), my (Malaysia), id (Indonesia), ph (Philippines), th (Thailand), vn (Vietnam). Defaults to 'sg'.

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

Lazada URLs to scrape; the mode is auto-detected per URL. Accepts product pages (e.g. 'https://www.lazada.sg/products/...-i1234567890-s9876543210.html'), category/shop pages (e.g. 'https://www.lazada.sg/shop-power-banks/'), and search-result URLs (e.g. 'https://www.lazada.sg/catalog/?q=laptop'). Leave empty if you are using the 'search' keyword instead. Each URL keeps its own country venue.

## `maxResults` (type: `integer`):

Maximum number of products to return across all searches and URLs combined. The actor stops (and stops charging) once this cap is reached. Defaults to 100. Set lower for cheap test runs; raise for large catalog pulls.

## `maxPagesPerList` (type: `integer`):

How many result pages to paginate through for each keyword search or category URL (each page yields up to ~40 products). Defaults to 5. Ignored for product detail URLs, which are always a single page. Raise to go deeper.

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

Proxy used for requests. Lazada blocks non-SEA datacenter IPs with an anti-bot challenge, so reliable scraping REQUIRES residential proxies located in the target country (Singapore, Malaysia, etc.). Select Apify RESIDENTIAL with the matching country, or supply your own SEA residential proxy URLs here. Datacenter proxy will usually be blocked.

## Actor input object example

```json
{
  "search": "robot vacuum",
  "country": "sg",
  "startUrls": [
    "https://www.lazada.sg/catalog/?q=mechanical+keyboard",
    "https://www.lazada.com.my/shop-power-banks/"
  ],
  "maxResults": 1,
  "maxPagesPerList": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All product records (listing and detail) scraped across the searches and URLs. Download as JSON, CSV, Excel, HTML, or RSS.

## `output` (type: `string`):

No description

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

No description

# 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 = {
    "search": "wireless earbuds",
    "country": "sg",
    "startUrls": [],
    "maxResults": 1,
    "maxPagesPerList": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "search": "wireless earbuds",
    "country": "sg",
    "startUrls": [],
    "maxResults": 1,
    "maxPagesPerList": 1,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/lazada-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 '{
  "search": "wireless earbuds",
  "country": "sg",
  "startUrls": [],
  "maxResults": 1,
  "maxPagesPerList": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/lazada-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/utNEUMfo1iqwjrl3z/builds/vVyl03OhAd19mutag/openapi.json