# Zigzag Scraper — Korean Women's Fashion Search & Prices (`kdatafactory/zigzag-scraper`) Actor

Scrape Zigzag (지그재그), Korea's largest women's fashion marketplace with 8,000+ shops. Keyword search or ranked feeds via Zigzag's own GraphQL API: product name, shop, KRW price, discount rate, review score and count, image and URL as clean JSON. For K-fashion research and price monitoring.

- **URL**: https://apify.com/kdatafactory/zigzag-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 6 total users, 2 monthly users, 92.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Zigzag Product Scraper 👗

Scrape **searched** and **ranked** women's-fashion products from [Zigzag](https://zigzag.kr) (지그재그) — Korea's largest women's-fashion marketplace, aggregating **8,000+ shops** — as clean, structured JSON. Get product names, shop names, KRW prices, discount rates, review scores, review counts, and images in one call.

Built for **K-fashion trend research**, **dropshipping product sourcing**, and **price monitoring**.

> **Try it free.** Apify's free plan includes $5 of monthly platform credit — roughly **1,250 results** from this actor, no credit card required. Set your input, click Start, and export JSON/CSV/Excel.

***

### What it does

This actor pulls product data directly from Zigzag's public GraphQL API — the same `GetSearchResult` operation that powers the zigzag.kr web app — so results are fast and complete, with clean cursor pagination. Two modes:

- **Search** — every product matching a keyword (e.g. `원피스` dress, `니트` knit, `nike`, `가디건` cardigan).
- **Ranking** — the same keyword feed, but each product is assigned a `rank` from its position in Zigzag's default recommendation order (Zigzag ranks its feed by a popularity/relevance blend).

***

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | `"search"` or `"ranking"`. |
| `query` | string | The search keyword. **Required.** e.g. `원피스`, `니트`, `nike`. |
| `maxItems` | integer | Max products to collect. Default `100`. |
| `proxyConfiguration` | object | Apify Proxy settings. Optional — runs direct if omitted. |

#### Input example

```json
{
  "mode": "ranking",
  "query": "원피스",
  "maxItems": 100
}
```

```json
{
  "mode": "search",
  "query": "니트",
  "maxItems": 200
}
```

***

### Output

Each product is one dataset record. Prices are in KRW (Korean won). `rating` is Zigzag's review score (0–5). `rank` is populated in ranking mode only.

Prices are reconstructed from Zigzag's `final_price` (what the customer pays) and `discount_rate`: when a product is discounted, `price_krw` is the original list price and `sale_price_krw` is the discounted price; when not discounted, `price_krw` holds the price and `sale_price_krw` is `null`.

```json
{
  "source": "zigzag",
  "product_id": "169746777",
  "name": "[🤍여름/MADE]라미 쉬폰 미니 원피스(+NEW컬러)(미니원피스 하객룩 여름원피스)",
  "brand": "메이빈스",
  "price_krw": 69895,
  "sale_price_krw": 39840,
  "discount_rate": 43,
  "rating": 4.8,
  "review_count": 111,
  "category": null,
  "rank": 1,
  "url": "https://store.zigzag.kr/app/catalog/products/169746777",
  "image_url": "https://cf.image-farm.s.zigzag.kr/original/ad/2026/6/12/202606121459580334_46155.png?width=720&height=720&quality=80&format=jpeg",
  "scraped_at": "2026-07-09T10:00:46+09:00"
}
```

A full 40-item sample from a real run is in [`samples/sample-output.json`](samples/sample-output.json).

| Field | Meaning |
|-------|---------|
| `source` | Always `"zigzag"`. |
| `product_id` | Zigzag catalog product id. |
| `name` | Product name. |
| `brand` | Shop / brand storefront name on Zigzag. |
| `price_krw` | Original list price (KRW). |
| `sale_price_krw` | Discounted price if on sale, else `null`. |
| `discount_rate` | Percent off (integer), or `null` when not discounted. |
| `rating` | Zigzag review score, 0–5 (`null` if none). |
| `review_count` | Number of reviews (`null` if none). |
| `category` | Always `null` — the search feed carries no per-item category label. |
| `rank` | Popularity/relevance rank (ranking mode only). |
| `url` | Product page URL. |
| `image_url` | Thumbnail image URL. |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

#### A note on what this actor does **not** return

To keep the data honest and privacy-safe, the actor deliberately does **not** sell fields that don't reliably populate or that identify people:

- **`category`** is always `null` on the search feed — it is kept in the schema for contract compatibility but is not a sold field.
- **Seller/reviewer identity** (nicknames, ids, profiles) is never collected — only shop storefront names and item/price data.

***

### Use cases

- **K-fashion trend research** — track which shops, styles, and price points dominate Zigzag's women's-fashion feed for a given keyword.
- **Dropshipping / product sourcing** — build a catalog of trending Korean women's-fashion products with images, shops, and prices to source or resell.
- **Price & discount monitoring** — watch `price_krw` vs `sale_price_krw` and `discount_rate` over time to catch drops and benchmark competitor pricing.
- **AI agents & datasets** — feed structured fashion data into recommendation models, market dashboards, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal catalog data — the same product listings any Zigzag visitor sees without logging in. No personal data is collected. You are responsible for how you use the data; see the legality note below.

**What does it cost in practice?**
$4.00 per 1,000 results + a few cents of platform usage. Example: a 500-result daily pull costs about $2.00/day. Apify's free $5 monthly credit covers ~1,250 results.

**Do I need to configure proxies?**
No — the default settings work out of the box. A proxy only helps against genuine `HTTP 403/429` rate limiting on heavy pulls (high `maxItems`); it cannot fix other failure modes. See the proxy note below for which is which.

**How fresh is the data?**
Every run scrapes the live site at run time. Schedule the actor for recurring snapshots.

**What is NOT included?**
`category` is always `null` — Zigzag's search feed carries no per-item category label, so it is kept only for schema compatibility. Seller/reviewer identity (nicknames, ids, profiles) is never collected — only shop storefront names and item/price data.

***

### 🤖 Use with AI agents (MCP)

Call this Actor as a tool from Claude or any MCP-compatible AI agent — no glue code. Point your MCP client at Apify's server, scoped to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=kdatafactory/zigzag-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull Zigzag women's-fashion search results on demand — no scraping code in your app. Grab a free token from [Apify → Integrations](https://console.apify.com/settings/integrations).

### 🇰🇷 More Korean data actors

This actor is part of a suite of Korean-platform scrapers by the same maintainer:

- [musinsa-scraper](https://apify.com/kdatafactory/musinsa-scraper) — Musinsa fashion products, rankings, and prices.
- [29cm-scraper](https://apify.com/kdatafactory/29cm-scraper) — 29CM curated fashion & lifestyle product data.
- [wconcept-scraper](https://apify.com/kdatafactory/wconcept-scraper) — W Concept designer fashion catalog and pricing.

Browse all: [apify.com/kdatafactory](https://apify.com/kdatafactory)

***

### Rate limiting & legality

- The actor collects **only public, non-authenticated data**. It never logs in and never touches private endpoints.
- **No personal data** is collected — no seller or reviewer names, profiles, or IDs. Only shop storefront names and item/price data.
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests, to stay gentle on Zigzag's servers.
- You are responsible for using the data in line with Zigzag's terms of service and applicable law.

#### ⚠️ Proxy recommendation

A proxy is **optional**, and only helps against one specific failure. The actor uses the proxy configuration you provide (via `proxyConfiguration` in input) and falls back to a direct connection when none is set or the tunnel is down.

**When a residential proxy helps:** repeated `GraphQL HTTP 403` or `HTTP 429` in the log. That is genuine rate limiting or an IP block, and switching on Apify Proxy with the `RESIDENTIAL` group — and/or lowering `maxItems` — is the right response.

**When it does not help:** an error reporting an *empty body* on an HTTP 200 (`x-cache: Error from cloudfront`), or a GraphQL contract mismatch. Those are request-shape rejections at Zigzag's CDN edge and they reproduce identically on residential, datacenter and direct connections — buying residential traffic cannot fix them. The actor's error message now says which case it observed, so please just report the run instead of paying for proxy traffic that will not change the outcome.

***

*If this actor saves you time, a rating on the [Store page](https://apify.com/kdatafactory/zigzag-scraper) helps a solo maintainer a lot. Found an issue? Open it in the Issues tab — I respond fast.*

***

### ⭐ Found it useful?

If this Actor saves you time, a short review on its Apify Store page helps other buyers find it. Missing a field or hit a bug? Open an issue on the **Issues** tab; reports are answered and fixed.

# Actor input Schema

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

What to scrape. 'search' returns products matching a keyword. 'ranking' returns the same keyword feed but assigns each product a popularity rank from its position in Zigzag's default recommendation order.

## `query` (type: `string`):

The search keyword to scrape (e.g. '원피스' dress, '니트' knit, 'nike', '가디건' cardigan). Required for both modes.

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

Maximum number of products to collect.

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

Apify Proxy settings. Optional: a RESIDENTIAL proxy only helps against genuine HTTP 403/429 rate limiting on large runs — it cannot fix CDN-edge rejections or API changes. If omitted, the actor runs on a direct connection.

## Actor input object example

```json
{
  "mode": "search",
  "query": "원피스",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every record collected in this run.

# 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 = {
    "query": "원피스"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kdatafactory/zigzag-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 = { "query": "원피스" }

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/zigzag-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "원피스"
}' |
apify call kdatafactory/zigzag-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kdatafactory/zigzag-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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