# EQL Store Scraper — Korean Designer Fashion Best-Sellers (`kdatafactory/eqlstore-scraper`) Actor

Daily best-seller rankings from EQL (eqlstore.com), the Handsome/Hyundai Dept Store premium designer-fashion mall. Get rank, brand, product name, KRW price, sold-out flag and image for WOMEN, MEN and LIFE departments as clean JSON. For K-fashion trend dashboards, price tracking and sourcing.

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

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## EQL Store Scraper — Korean Designer Fashion Best-Sellers 🛍️

Scrape the **daily best-seller rankings** from [EQL (eqlstore.com)](https://www.eqlstore.com) — the premium designer-fashion mall run by **Handsome**, part of the **Hyundai Department Store** group — as clean, structured JSON. Get the rank, brand, product name, price (KRW), sold-out flag, and image for every best-selling product across EQL's **WOMEN**, **MEN**, and **LIFE** departments in one run.

> **Note:** EQL here is **eqlstore.com** (Handsome / Hyundai Dept Store), a Korean designer-fashion retailer — *not* the unrelated company at eql.com.

The perfect **daily trend feed** for a Korean e-commerce dashboard: run it on a schedule and you get a fresh top-of-market ranking every day, ready to chart movers, new entries, and sell-outs.

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

***

### What it does

This actor reads ranking data straight from EQL's own best-seller feed (the same endpoint the website calls as you browse a category's "BEST" tab), so results are fast and complete — no fragile full-page scraping, no headless browser. You can scrape:

- **All three departments at once** (WOMEN + MEN + LIFE, each with its own ranking), or
- **A single department** (e.g. just WOMEN, or just LIFE).

Every product is returned with its live **daily best-seller rank** (`sort=DAILY_SALE_SEQ`), so the output is a ready-made leaderboard.

> **Why EQL?** EQL is Handsome's flagship premium-designer platform (Hyundai Department Store group), carrying labels like ARC'TERYX, ASICS, and a deep bench of Korean designer brands. Its daily best-seller list is a clean, high-signal read on what premium Korean shoppers are actually buying — ideal for a shopping-trend dashboard, brand monitoring, or product sourcing. This actor turns that ranking into a structured dataset you can filter, chart, and pipe into your own tools.

***

### Input

| Field | Type | Description |
|-------|------|-------------|
| `department` | string | Which best-seller department to scrape: `all` (WOMEN + MEN + LIFE), `women`, `men`, or `life`. Default `all`. |
| `maxItems` | integer | Max best-seller products to collect **per department**. The EQL daily best list runs ~100–120 items per department. Default `120`, max `1000`. |
| `proxyConfiguration` | object | Proxy settings (see below). Defaults to a direct connection. |

With `department: "all"` the actor collects up to `maxItems` products for **each** of the three departments, so a default run returns roughly 300 records (the full best list of all three), each tagged with its own `dept` and per-department `rank`.

#### Input example

```json
{
  "department": "all",
  "maxItems": 120
}
```

```json
{
  "department": "women",
  "maxItems": 40
}
```

***

### Output

Each best-selling product is one dataset record. `rank` is the product's position in that department's live daily best-seller list (1 = top seller). `price_krw` is the current sale price in Korean won. `is_sold_out` flags products EQL marks as sold out. `dept` tells you which department leaderboard the record belongs to.

```json
{
  "source": "eql",
  "dept": "women",
  "rank": 1,
  "product_id": "GP9026070881271",
  "brand": "ASICS",
  "name": "[아식스 본사]젤 카야노 14 112639301-006",
  "price_krw": 189000,
  "is_sold_out": false,
  "url": "https://www.eqlstore.com/product/GP9026070881271/detail",
  "image_url": "https://cdn.eqlstore.com/goods/EQBR/26/07/08/GP9026070881271_0_ORGINL_1783577228170.jpg",
  "scraped_at": "2026-07-15T09:56:22+09:00"
}
```

A 30-item sample from a real run (WOMEN + MEN + LIFE) is in [`samples/sample-output.json`](samples/sample-output.json).

| Field | Meaning |
|-------|---------|
| `source` | Always `"eql"`. |
| `dept` | Department leaderboard: `women`, `men`, or `life`. |
| `rank` | Daily best-seller rank within the department (1 = top seller). |
| `product_id` | EQL product code (`godNo`). |
| `brand` | Brand name, as EQL labels it. |
| `name` | Full product name (Korean/English as listed). |
| `price_krw` | Current sale price in KRW. |
| `is_sold_out` | `true` when EQL marks the product sold out. |
| `url` | Product detail page URL. |
| `image_url` | Main product photo URL (CDN). |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

The core fields — `rank`, `brand`, `name`, `price_krw`, `dept`, `url`, `image_url` — populated on **300/300** records in the live test across all three departments. `is_sold_out` is always a boolean.

***

### Use cases

- **Daily K-fashion trend dashboards** — schedule the actor daily and chart the WOMEN/MEN/LIFE best-seller leaderboards: track new entries, rank movers, and sell-outs over time from a clean, structured feed.
- **Brand & competitor monitoring** — see which brands own the top of EQL's premium-designer ranking, and how their products move day to day.
- **Price monitoring** — track `price_krw` and `is_sold_out` on top sellers to catch price changes and stock-outs on high-demand designer items.
- **Product sourcing & research** — build a filterable catalogue of proven best-selling Korean designer products (with photos, brand, and price) for buying, dropshipping, or market research.
- **AI agents & datasets** — feed structured best-seller rankings into trend models, dashboards, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal best-seller data — the same ranking any visitor sees on eqlstore.com without logging in. No personal data of any kind is collected. You are responsible for how you use the data; see the legality note below.

**What does it cost in practice?**
$2.00 per 1,000 results (launch pricing) + a few cents of platform usage. Example: a daily `all`-departments pull of ~300 products costs about **$0.60/day**. Apify's free $5 monthly credit covers **~2,500 results** (5 ÷ 2 × 1,000).

**Do I need to configure proxies?**
No — the default settings work out of the box. EQL serves its best-seller feed without a bot wall, so the actor runs fine on a **direct connection**. For very heavy pulls you can optionally enable Apify Proxy — see the proxy note below.

**How fresh is the data?**
Every run scrapes EQL's live daily best-seller feed (`DAILY_SALE_SEQ`) at run time. Schedule the actor daily to build a time series of the rankings.

**Is EQL the same as eql.com?**
No. This actor targets **eqlstore.com**, the Korean designer-fashion mall operated by Handsome (Hyundai Department Store group). It is unrelated to eql.com.

**What is NOT included?**
Only the best-seller list fields are returned (rank, brand, name, price, sold-out flag, image). This actor does not open each product's detail page, so per-item extras like full descriptions, sizes, or review text are not collected. Brand and product names come as EQL lists them (mostly Korean, some English).

***

### 🤖 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/eqlstore-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull EQL best-seller rankings and Korean designer-fashion trend data 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:

- **[29cm-scraper](https://apify.com/kdatafactory/29cm-scraper) — designer-curation products from 29CM, Korea's premium lifestyle store.** Pair it with this actor for broader premium K-fashion coverage.
- **[wconcept-scraper](https://apify.com/kdatafactory/wconcept-scraper) — designer-fashion catalogue from W Concept (3,000+ labels), with USD prices.** Another Handsome-adjacent designer marketplace.
- [musinsa-scraper](https://apify.com/kdatafactory/musinsa-scraper) — products and rankings from Musinsa, Korea's #1 fashion platform.
- [zigzag-scraper](https://apify.com/kdatafactory/zigzag-scraper) — women's-fashion rankings from Zigzag, Korea's top fashion app.

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 — only public product ranking fields (rank, brand, name, price, sold-out flag, image).
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests (and between departments), to stay gentle on EQL's servers.
- You are responsible for using the data in line with EQL's terms of service and applicable law.

#### Known limitations (honesty note)

- **List-level fields only.** This actor returns the best-seller list fields (rank, brand, name, price, sold-out flag, image). It deliberately does **not** open each product's detail page, so per-item extras (descriptions, sizes, full review text) are not collected.
- **Rank is per department.** `rank` is the product's position within its own department's daily best list (WOMEN, MEN, or LIFE) — it is not a single cross-store ranking. Use `dept` to keep the three leaderboards separate.
- **Names/brands are as listed.** Product and brand names come exactly as EQL labels them (mostly Korean, some English); they are not translated.
- **`price_krw` is the current sale price** shown on the best-seller card. Original/list price and discount rate are not exposed on the list feed and are not returned.

***

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

# Actor input Schema

## `department` (type: `string`):

Which EQL best-seller department to scrape. 'all' collects all three (WOMEN, MEN, LIFE), each with its own daily ranking.

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

Maximum number of best-seller products to collect per department (the EQL daily best list runs ~100–120 items per department). With department 'all', up to this many are collected for each of the three departments.

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

Proxy settings. EQL serves its best-seller feed without a bot wall, so the actor runs fine on a direct connection (default). If you ever see blocks at high volume, enable Apify Proxy here.

## Actor input object example

```json
{
  "department": "all",
  "maxItems": 120,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {};

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

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/eqlstore-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 '{}' |
apify call kdatafactory/eqlstore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/UAn7bNM3Qaetp1tfZ/builds/Ix3Bbn7n6dGY0Qbxa/openapi.json