# Lazada Scraper - Scrape Products & Prices (`logiover/lazada-scraper`) Actor

Lazada product scraper & unofficial API alternative. Scrape prices, ratings, sellers across SEA without login; export Lazada data to CSV or JSON.

- **URL**: https://apify.com/logiover/lazada-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Business, Marketing
- **Stats:** 3 total users, 2 monthly users, 92.6% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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 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, prices & sellers

Scrape Lazada product listings by keyword or category URL and export clean pricing, ratings and sales data. This **Lazada product scraper** covers six Southeast Asian marketplaces - Malaysia, Singapore, Indonesia, Philippines, Vietnam and Thailand - with no login, no cookies and no API key.

Feed it search terms (like `phone`, `wireless earbuds` or `air fryer`) and/or full Lazada category URLs, and it paginates each query to pull **hundreds of products per search**. It is the fast way to build a Lazada price-monitoring or market-research dataset.

### What you get

Every Lazada product becomes one flat record. Fields include:

- **name** - product title
- **price / priceShow** - numeric price and display string (e.g. `RM899.00`)
- **originalPrice / originalPriceShow** - pre-discount price
- **discount** - discount percentage (e.g. `-31%`)
- **currency** - marketplace currency code
- **ratingScore** - average star rating
- **review** - number of reviews
- **sold / itemSoldCntShow** - units sold (numeric and display, e.g. `5.2K sold`)
- **sellerName / sellerId** - seller identity
- **brandName** - product brand
- **location** - seller / shipping location
- **inStock / isSponsored** - stock flag and sponsored-listing flag
- **image** - main product image URL
- **itemUrl** - direct product link
- **country / searchTerm / scrapedAt** - marketplace, source query and scrape timestamp

Export the dataset to **CSV, JSON, Excel**, HTML, or pull it via the Apify API and webhooks.

### Use cases

- **Price monitoring** - track competitor and own-listing prices across SEA markets on a schedule.
- **Market & demand research** - read sold counts and ratings to size demand per category.
- **Sellers & brands** - benchmark assortment, pricing and discounts against rivals.
- **Product sourcing & dropshipping** - find trending items and best-sellers per marketplace.
- **Datasets & analytics** - build labelled product datasets per category and country for BI or ML.

### How to use

1. Click **Try for free** / **Start**.
2. In **Search terms** add one or more keywords (for example `phone`, `wireless earbuds`). Each term is paginated independently.
3. Optional: paste full Lazada **category / search URLs** (e.g. `https://www.lazada.com.my/shop-mobiles/`) instead of, or together with, keywords.
4. Pick the **marketplace country** - `MY`, `SG`, `ID`, `PH`, `VN` or `TH`. The residential proxy is auto-matched to it.
5. Set **Max items per term** and **Max results** to control depth.
6. Run it, then download CSV, JSON or Excel from the **Storage / Dataset** tab.

#### Example input

```json
{
  "searchTerms": ["phone", "wireless earbuds"],
  "country": "MY",
  "maxItemsPerTerm": 300,
  "maxResults": 1000
}
````

#### Example output

```json
{
  "name": "Xiaomi Redmi Note 13 Pro 5G 8GB+256GB Smartphone",
  "price": 899,
  "priceShow": "RM899.00",
  "originalPrice": 1299,
  "discount": "-31%",
  "currency": "MYR",
  "ratingScore": 4.8,
  "review": 1243,
  "sold": 5200,
  "itemSoldCntShow": "5.2K sold",
  "sellerName": "Xiaomi Official Store",
  "brandName": "Xiaomi",
  "location": "Selangor",
  "inStock": true,
  "image": "https://my-live.slatic.net/p/....jpg",
  "itemUrl": "https://www.lazada.com.my/products/....html",
  "country": "MY",
  "searchTerm": "phone",
  "scrapedAt": "2026-06-04T08:00:00.000Z"
}
```

### How it works

The actor loads each search term or category URL in a headless browser over a country-matched residential proxy, intercepts Lazada's catalog JSON (`mods.listItems`), and parses every product. Pagination walks subsequent pages until your `maxItemsPerTerm` or `maxResults` limit is hit. No Lazada account is ever used or risked.

### FAQ

#### Do I need a Lazada login or API key?

No. The Lazada scraper reads public catalog data only - no account, no cookies and no developer API key. There is no public Lazada product API for bulk scraping, so this is the practical alternative.

#### Which countries and marketplaces are supported?

All six Lazada marketplaces: Malaysia (lazada.com.my), Singapore (lazada.sg), Indonesia (lazada.co.id), Philippines (lazada.com.ph), Vietnam (lazada.vn) and Thailand (lazada.co.th). The proxy country is matched automatically to the marketplace you pick.

#### Why does it need residential proxies?

Lazada runs on Alibaba anti-bot infrastructure that walls datacenter traffic. A country-matched residential proxy is decisive for staying unblocked, so it is the default and is set up for you.

#### How many products can I scrape per search?

Hundreds per term. It paginates the result pages, and you control depth with `maxItemsPerTerm` per query and the global `maxResults` cap.

#### Can I export to CSV or Excel?

Yes. Every run can be downloaded as CSV, JSON, Excel or HTML, or pulled programmatically through the Apify API and webhooks (Google Sheets, BigQuery, your warehouse).

#### Is this a Lazada API alternative?

Yes. Lazada has no public product API for bulk catalog access, so this scraper is the practical unofficial API alternative - it returns the same listing fields (price, rating, sold count, seller) as structured records.

#### How do I scrape Lazada without login or an API key?

Just enter search terms or category URLs and pick a marketplace country. The actor reads public catalog data over a country-matched residential proxy, so no Lazada account, cookies or developer key are needed.

#### How do I export Lazada product data to CSV or JSON?

Run the actor, then open the Storage / Dataset tab and download the results as CSV, JSON or Excel. You can also fetch the same Lazada dataset programmatically via the Apify API.

***

*Collects publicly available product data only. You are responsible for compliance with Lazada's Terms and applicable laws, including bulk-access limits.*

### Changelog

#### 2026-06-07

- Docs: added coverage for Lazada API alternative, scraping without login, and exporting Lazada product data to CSV/JSON.

#### 2026-06-05

- Reliability fix: results are no longer dropped by strict output validation - runs complete cleanly at high volume.
- Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build - reliability/maintenance pass.

# Actor input Schema

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

Keywords to search on Lazada (e.g. 'phone', 'wireless earbuds', 'air fryer'). Each term is paginated up to the per-term limit.

## `categoryUrls` (type: `array`):

Optional. Full Lazada category or search-result URLs to scrape directly (e.g. https://www.lazada.com.my/shop-mobiles/). Use instead of, or together with, search terms.

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

Which Lazada marketplace to scrape. The residential proxy is automatically matched to this country, which is decisive for staying unblocked.

## `maxItemsPerTerm` (type: `integer`):

Maximum products to collect per search term / category URL (paginated).

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

Global cap on products saved across all terms. 0 = unlimited.

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

Lazada requires country-matched RESIDENTIAL proxies. Leave the default — the country is auto-aligned to the selected marketplace.

## Actor input object example

```json
{
  "searchTerms": [
    "phone",
    "wireless earbuds"
  ],
  "categoryUrls": [
    "https://www.lazada.com.my/shop-mobiles/"
  ],
  "country": "MY",
  "maxItemsPerTerm": 25,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "MY"
  }
}
```

# Actor output Schema

## `name` (type: `string`):

Product name

## `priceShow` (type: `string`):

Display price

## `ratingScore` (type: `string`):

Rating score

## `sold` (type: `string`):

Units sold

## `sellerName` (type: `string`):

Seller name

## `itemUrl` (type: `string`):

Product URL

# 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 = {
    "searchTerms": [
        "phone"
    ],
    "maxItemsPerTerm": 25,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "MY"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "searchTerms": ["phone"],
    "maxItemsPerTerm": 25,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "MY",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "searchTerms": [
    "phone"
  ],
  "maxItemsPerTerm": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "MY"
  }
}' |
apify call logiover/lazada-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lazada Scraper - Scrape Products & Prices",
        "description": "Lazada product scraper & unofficial API alternative. Scrape prices, ratings, sellers across SEA without login; export Lazada data to CSV or JSON.",
        "version": "1.0",
        "x-build-id": "MBOCbYRx5Pcwqb8Hi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~lazada-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-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/logiover~lazada-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-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/logiover~lazada-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search on Lazada (e.g. 'phone', 'wireless earbuds', 'air fryer'). Each term is paginated up to the per-term limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category / search URLs",
                        "type": "array",
                        "description": "Optional. Full Lazada category or search-result URLs to scrape directly (e.g. https://www.lazada.com.my/shop-mobiles/). Use instead of, or together with, search terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Marketplace country",
                        "enum": [
                            "MY",
                            "SG",
                            "ID",
                            "PH",
                            "VN",
                            "TH"
                        ],
                        "type": "string",
                        "description": "Which Lazada marketplace to scrape. The residential proxy is automatically matched to this country, which is decisive for staying unblocked.",
                        "default": "MY"
                    },
                    "maxItemsPerTerm": {
                        "title": "Max items per term",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum products to collect per search term / category URL (paginated).",
                        "default": 200
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Global cap on products saved across all terms. 0 = unlimited.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Lazada requires country-matched RESIDENTIAL proxies. Leave the default — the country is auto-aligned to the selected marketplace.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "MY"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
