# Zalora Fashion Scraper (`crawlerbros/zalora-scraper`) Actor

Scrape Zalora with Southeast Asia's leading fashion and lifestyle marketplace. Search products, browse by category, across PH, MY, ID, HK, and SG markets. Returns prices, ratings, brands, images, and discount info.

- **URL**: https://apify.com/crawlerbros/zalora-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Zalora Fashion Scraper

Scrape product listings from **Zalora** — Southeast Asia's leading fashion and lifestyle marketplace. Search by keyword or browse by category across Philippines, Malaysia, Indonesia, Hong Kong, and Singapore.

### What You Can Scrape

- **Product search** — find any fashion item by keyword across all markets
- **Category browse** — browse Women, Men, Kids, Beauty, or Sale sections
- **Full product details** — prices, discounts, ratings, reviews, images, and brand info

### Output Fields

Each record contains:

| Field | Description |
|---|---|
| `sku` | Zalora product SKU (config SKU) |
| `name` | Product name |
| `brand` | Brand name |
| `seller` | Seller / supplier name |
| `price` | Current (effective) price in local currency |
| `originalPrice` | Original price before discount (if on sale) |
| `discountPercent` | Discount percentage (e.g. `30` for 30% off) |
| `currency` | Currency code (e.g. `PHP`, `MYR`, `IDR`) |
| `market` | Market code (e.g. `ph`, `my`, `id`) |
| `rating` | Average customer rating (1–5 stars) |
| `reviewCount` | Number of customer reviews |
| `url` | Full product page URL |
| `imageUrl` | Main product image URL |
| `additionalImages` | Array of additional product image URLs |
| `category` | Top-level category (e.g. `"Women"`) |
| `subcategory` | Sub-category (e.g. `"Dresses in Women"`) |
| `breadcrumb` | Full category path (e.g. `"Women > Clothing > Dresses"`) |
| `isOnSale` | Whether the product is currently on sale |
| `isOfficialStore` | Whether sold by an official brand store |
| `saleLabel` | Sale label text (e.g. `"50% Off"`) |
| `daysListed` | How many days the product has been listed |
| `scrapedAt` | ISO 8601 timestamp of when the record was scraped |

### Input

| Parameter | Type | Description |
|---|---|---|
| `mode` | select | `search` (default) or `byCategory` |
| `market` | select | Country market: `ph`, `my`, `id`, `hk`, `sg` |
| `searchQuery` | string | Keyword to search (mode=search) |
| `segment` | select | Category segment: `women`, `men`, `kids`, `beauty`, `sale`, `all` |
| `categoryUrlKey` | string | Category slug (e.g. `dresses`, `shoes`, `bags`) |
| `sortBy` | select | Sort: most popular, newest, price asc/desc, biggest discount |
| `minPrice` | integer | Minimum price in local currency |
| `maxPrice` | integer | Maximum price in local currency |
| `onSaleOnly` | boolean | Return only discounted products |
| `maxItems` | integer | Max records to return (default: 50) |

### Supported Markets

| Code | Market | Currency | Domain |
|---|---|---|---|
| `ph` | Philippines | PHP | zalora.com.ph |
| `my` | Malaysia | MYR | zalora.com.my |
| `id` | Indonesia | IDR | zalora.co.id |
| `hk` | Hong Kong | HKD | zalora.com.hk |
| `sg` | Singapore | SGD | zalora.sg |

### Example Inputs

**Search for dresses in Philippines:**
```json
{
  "mode": "search",
  "market": "ph",
  "searchQuery": "dress",
  "maxItems": 50
}
````

**Browse women's shoes in Malaysia:**

```json
{
  "mode": "byCategory",
  "market": "my",
  "segment": "women",
  "categoryUrlKey": "shoes",
  "maxItems": 100
}
```

**Sale items under RM 50 in Malaysia:**

```json
{
  "mode": "search",
  "market": "my",
  "searchQuery": "top",
  "onSaleOnly": true,
  "maxPrice": 50,
  "maxItems": 50
}
```

**Browse men's sneakers in Singapore:**

```json
{
  "mode": "byCategory",
  "market": "sg",
  "segment": "men",
  "categoryUrlKey": "sneakers",
  "sortBy": "priceDes",
  "maxItems": 50
}
```

### Use Cases

- **Competitive price monitoring** — track fashion prices across SE Asian markets
- **Trend analysis** — discover trending products and categories
- **Brand research** — find all products from a specific brand
- **Deal hunting** — scrape the biggest discounts and sale items
- **Market comparison** — compare pricing across PH, MY, ID, HK, SG

### Data Source

This actor scrapes **Zalora** via its public product API, accessible without authentication. Zalora operates across Southeast Asia as part of Global Fashion Group. Data is publicly available on the website.

### FAQ

**Which markets are supported?**
Philippines (ph), Malaysia (my), Indonesia (id), Hong Kong (hk), and Singapore (sg). Each market has independent product catalogues and pricing.

**How many products can I scrape?**
The Zalora API returns up to 36 products per page. The actor paginates through all results up to your `maxItems` limit. Total product catalogue size varies by market (20,000–30,000+ per market).

**Can I filter by brand?**
Currently the actor supports keyword search (which matches brand names) and category browsing. Search for the brand name in `searchQuery` to find brand-specific products.

**What does `discountPercent` mean?**
When a product has a `SpecialPrice` (sale price) lower than its regular price, `discountPercent` shows the percentage reduction (e.g. `30` means 30% off).

**Are prices in local currency?**
Yes. Prices are in the local currency of each market: PHP for Philippines, MYR for Malaysia, IDR for Indonesia, HKD for Hong Kong, SGD for Singapore.

# Actor input Schema

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

Scraping mode: search products by keyword, or browse by category segment.

## `market` (type: `string`):

Zalora market / country to scrape.

## `searchQuery` (type: `string`):

Keyword to search for. Example: `dress`, `sneakers`, `laptop bag`.

## `segment` (type: `string`):

Browse a Zalora segment/category. Use the segment value from Zalora (e.g. `women`, `men`, `kids`, `beauty`, `sale`).

## `categoryUrlKey` (type: `string`):

Zalora category URL key to browse (e.g. `dresses`, `shoes`, `bags`, `tops`). Leave blank to browse the full segment.

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

Product sort order.

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

Minimum product price in local currency.

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

Maximum product price in local currency.

## `onSaleOnly` (type: `boolean`):

Return only discounted / on-sale products.

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

Maximum number of product records to return.

## Actor input object example

```json
{
  "mode": "search",
  "market": "ph",
  "searchQuery": "dress",
  "segment": "women",
  "sortBy": "pop",
  "onSaleOnly": false,
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Zalora product listings.

# 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 = {
    "mode": "search",
    "market": "ph",
    "searchQuery": "dress",
    "segment": "women",
    "sortBy": "pop",
    "onSaleOnly": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zalora-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 = {
    "mode": "search",
    "market": "ph",
    "searchQuery": "dress",
    "segment": "women",
    "sortBy": "pop",
    "onSaleOnly": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zalora-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 '{
  "mode": "search",
  "market": "ph",
  "searchQuery": "dress",
  "segment": "women",
  "sortBy": "pop",
  "onSaleOnly": false,
  "maxItems": 50
}' |
apify call crawlerbros/zalora-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zalora Fashion Scraper",
        "description": "Scrape Zalora with Southeast Asia's leading fashion and lifestyle marketplace. Search products, browse by category, across PH, MY, ID, HK, and SG markets. Returns prices, ratings, brands, images, and discount info.",
        "version": "1.0",
        "x-build-id": "Cnpl133JZMAJwptsP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~zalora-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-zalora-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/crawlerbros~zalora-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-zalora-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/crawlerbros~zalora-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-zalora-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "Scraping mode: search products by keyword, or browse by category segment.",
                        "default": "search"
                    },
                    "market": {
                        "title": "Market",
                        "enum": [
                            "ph",
                            "my",
                            "id",
                            "hk",
                            "sg"
                        ],
                        "type": "string",
                        "description": "Zalora market / country to scrape.",
                        "default": "ph"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Keyword to search for. Example: `dress`, `sneakers`, `laptop bag`.",
                        "default": "dress"
                    },
                    "segment": {
                        "title": "Segment / category (mode=byCategory)",
                        "enum": [
                            "women",
                            "men",
                            "kids",
                            "beauty",
                            "sale",
                            "all"
                        ],
                        "type": "string",
                        "description": "Browse a Zalora segment/category. Use the segment value from Zalora (e.g. `women`, `men`, `kids`, `beauty`, `sale`).",
                        "default": "women"
                    },
                    "categoryUrlKey": {
                        "title": "Category URL key (mode=byCategory)",
                        "type": "string",
                        "description": "Zalora category URL key to browse (e.g. `dresses`, `shoes`, `bags`, `tops`). Leave blank to browse the full segment."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "pop",
                            "new",
                            "priceAsc",
                            "priceDes",
                            "discount"
                        ],
                        "type": "string",
                        "description": "Product sort order.",
                        "default": "pop"
                    },
                    "minPrice": {
                        "title": "Min price (local currency)",
                        "minimum": 0,
                        "maximum": 99999999,
                        "type": "integer",
                        "description": "Minimum product price in local currency."
                    },
                    "maxPrice": {
                        "title": "Max price (local currency)",
                        "minimum": 0,
                        "maximum": 99999999,
                        "type": "integer",
                        "description": "Maximum product price in local currency."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Return only discounted / on-sale products.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of product records to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
