# 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:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Scrape **Lazada** products across all six Southeast Asia venues — **Singapore, Malaysia, Indonesia, Philippines, Thailand, and Vietnam** — by **keyword search**, **category/shop URL**, or **product URL**. The mode is auto-detected. Returns clean, structured JSON: price, discount, rating, reviews, sold count, seller, brand, location, and image. HTTP-only (no browser, no login), and MCP-ready for AI agents.

### What you can do

| Input | What you get |
|-------|--------------|
| **Keyword** (e.g. `wireless earbuds`) + venue | A search result grid of products, auto-paginated |
| **Category / shop URL** (e.g. `https://www.lazada.sg/shop-power-banks/`) | Every product on the listing, auto-paginated |
| **Product URL** (e.g. `https://www.lazada.sg/products/...-i123-s456.html`) | A single product metadata record (name, brand, category, breadcrumbs, image, description; price & rating when Lazada publishes them on the page) |

### Output fields

| Field | Description |
|-------|-------------|
| `type` | `listing` (search/category card) or `detail` (product page) |
| `itemId`, `skuId` | Lazada product and SKU ids |
| `name` | Product title |
| `url` | Canonical product URL |
| `brand` | Brand when exposed |
| `price`, `priceValue` | Formatted price (`S$29.90`) and numeric value (`29.9`) |
| `originalPrice`, `discount` | Pre-discount price and discount label (`-50%`) |
| `currency` | Venue currency (`SGD`, `MYR`, `IDR`, `PHP`, `THB`, `VND`) |
| `ratingScore`, `reviewCount` | Average stars and number of reviews |
| `soldCount` | Sold-count label (`2K sold`) when shown |
| `sellerName`, `sellerId`, `location` | Seller info and ship-from location |
| `imageUrl` | Primary image |
| `venue` | `sg` / `my` / `id` / `ph` / `th` / `vn` |
| `sourceUrl`, `scrapedAt` | Provenance and ISO 8601 timestamp |

### Pricing (Pay-Per-Event)

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| Product (`product`) | **$0.003** |

You pay $0.003 per product returned, whether from a keyword search, a category/shop listing, or a product URL. Pay-Per-Usage (compute + proxy) is also available — pick whichever billing suits your job size. A 100-result search run costs about **$0.30**.

> **Search & category cards always include price, rating, sold count, and seller.** A product (PDP) URL returns rich metadata (name, brand, category, breadcrumbs, images, description, availability); its live price and rating are included when Lazada publishes them in the page. For guaranteed prices at scale, use keyword search or category mode.

### Example input

```json
{
  "search": "robot vacuum",
  "country": "sg",
  "maxResults": 100,
  "maxPagesPerList": 5
}
````

Or by URL (each URL keeps its own country):

```json
{
  "startUrls": [
    "https://www.lazada.com.my/catalog/?q=mechanical+keyboard",
    "https://www.lazada.sg/products/sample-i1234567890-s9876543210.html"
  ],
  "maxResults": 50
}
```

### Proxies — important

Lazada (an Alibaba company) protects its sites with the **Baxia / RGV587 anti-bot system** and serves its content only to visitors located in the target Southeast Asia country. **Datacenter proxies are blocked.** For reliable results you must use **residential proxies located in the venue country**:

- Select **Apify Residential** proxy with the matching country (Singapore for `lazada.sg`, Malaysia for `lazada.com.my`, and so on), **or**
- Supply your own SEA residential proxy URLs in `proxyConfiguration`.

If you run with datacenter proxy you will usually get an anti-bot challenge and zero results — the run reports this honestly rather than pretending to succeed.

### Use with AI agents (MCP)

This actor is exposed through the Apify MCP server as `apify--lazada-scraper`. An agent can call it with a single keyword or URL and receive structured product JSON — ideal for price comparison, market research, and competitor monitoring across Southeast Asia.

### Common use cases

- **Price & promo monitoring** across SEA marketplaces.
- **Competitor catalog tracking** — pull a shop's full listing.
- **Market research** — category coverage, ratings, and sold-count signals.
- **Product enrichment** — resolve a Lazada URL to a clean record.

### FAQ

**Which countries are supported?** All six Lazada venues: Singapore (`sg`), Malaysia (`my`), Indonesia (`id`), Philippines (`ph`), Thailand (`th`), Vietnam (`vn`).

**Does keyword search work?** Yes — set `search` and `country`. The actor runs the search on that venue and paginates the result grid.

**Do I need a login or cookies?** No. The actor reads Lazada's server-rendered product data; no account is required.

**Why did I get zero results?** Almost always a proxy issue — use residential proxies in the target country (see *Proxies* above). It can also mean the search/URL genuinely has no listings.

**How many products per page?** Search and category pages return roughly 40 products each; raise `maxPagesPerList` to go deeper.

### Legal & responsible use

This actor collects only **publicly available** product information from Lazada and performs no login or access to private data. You are responsible for ensuring your use complies with Lazada's Terms of Service, applicable laws, and data-protection regulations (including the GDPR and local equivalents) in your jurisdiction. Do not use scraped data to infringe intellectual property or for any unlawful purpose. This actor is not affiliated with, endorsed by, or sponsored by Lazada or the Alibaba Group.

# 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": 100,
  "maxPagesPerList": 5,
  "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.

# 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": 100,
    "maxPagesPerList": 5,
    "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": 100,
    "maxPagesPerList": 5,
    "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": 100,
  "maxPagesPerList": 5,
  "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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lazada Scraper — Prices, Ratings & Seller Data",
        "description": "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.",
        "version": "0.1",
        "x-build-id": "nhJULehVSG62459T4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~lazada-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-lazada-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~lazada-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-lazada-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~lazada-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-lazada-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "search": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "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": {
                        "title": "Lazada venue (for keyword search)",
                        "enum": [
                            "sg",
                            "my",
                            "id",
                            "ph",
                            "th",
                            "vn"
                        ],
                        "type": "string",
                        "description": "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'.",
                        "default": "sg"
                    },
                    "startUrls": {
                        "title": "Lazada URLs",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "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.",
                        "default": 100
                    },
                    "maxPagesPerList": {
                        "title": "Max pages per search/category",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "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.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "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.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
