# Musinsa Products: New Arrivals & Sale Prices (Korea) (`superslowsloth/musinsa-products`) Actor

List Musinsa products by category and get one flat row per product: price in KRW at every stage (tag, markdown, coupon, final), discount %, brand, gender, reviews and score, image and URL. Sort by new arrivals, discount, price or best sellers. Korean fashion price and markdown watch.

- **URL**: https://apify.com/superslowsloth/musinsa-products.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.31 / 1,000 product scrapeds

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

## Musinsa Products Scraper: New Arrivals & Sale Prices (Korea)

This Musinsa scraper lists the products in any [Musinsa](https://www.musinsa.com)
category, Korea's largest online fashion marketplace, and returns one flat row per
product: the price in Korean won **at every stage** (tag price, after Musinsa's
markdown, after a coupon, and the final price a buyer pays), the discount
percentages, brand, gender, review count and score, image, product URL and its
rank in the list. Sort by **new arrivals** to watch launches, by **biggest
discount** to watch markdowns, or by best sellers over a day, week, month or
year. Run it on a schedule and diff the dataset to get a **Korean fashion price,
markdown and new-arrival feed** per category.

No account, no API key, no login, no browser. One request returns up to 100
products.

### Input

| Field | Notes |
|---|---|
| `categories` | One or more category codes, one per line. Required. A musinsa.com category link works too. A product listed under two categories is returned once, under the first. |
| `maxItems` | Products to read **per category** (default 100, up to 100,000). 100 per page. |
| `sort` | `NEW` (default: newest first), `POPULAR` (Musinsa's recommended order), `LOW_PRICE`, `HIGH_PRICE`, `DISCOUNT_RATE`, `REVIEW`, and best sellers over `SALE_ONE_DAY_COUNT`, `SALE_ONE_WEEK_COUNT`, `SALE_ONE_MONTH_COUNT`, `SALE_THREE_MONTH_COUNT`, `SALE_ONE_YEAR_COUNT`. |
| `gender` | `all` (default), `men` or `women`. Men and women both include the unisex products, so they overlap. |
| `proxyConfiguration` | Apify proxy by default (see "How it fetches"). |

#### Category codes

A 3-digit code is a top-level category; a 6-digit code is a sub-category inside
one. Codes are Musinsa's own, read from its category API on 2026-10-14.

| Code | Category | Code | Category |
|---|---|---|---|
| `001` | Tops | `103` | Shoes |
| `002` | Outerwear | `120` | Hats |
| `003` | Pants | `101` | Accessories |
| `100` | Dresses and skirts | `026` | Underwear and homewear |
| `004` | Bags | `017` | Sports and leisure |
| `104` | Beauty | `102` | Digital and lifestyle |
| `122` | Food and health | `107` | Outlet |
| `105` | Boutique | `106` | Kids |
| `108` | 어스 | `111` | K-Connect |
| `109` | Used (pre-owned) | | |

Some sub-categories: `001001` short-sleeve tees, `001002` shirts and blouses,
`001004` hoodies, `001005` sweatshirts, `001006` knitwear, `002001` blouson and
MA-1, `002007` winter coats, `002012` short padded jackets, `003002` denim,
`003008` slacks, `004001` backpacks, `100001` mini dresses, `103004` sneakers,
`103002` boots, `120001` caps.

**A wrong code is not an error.** Musinsa answers a code it does not have (and
any 9-digit code) with an empty list, exactly as it answers an empty category.
The actor accepts only 3- or 6-digit codes and rejects anything else before the
run starts, and it logs `no products for category ...` for a code that returned
nothing.

### Output

Prices are numbers in Korean won (`currency` is always `KRW`).

| Field | Notes |
|---|---|
| `category`, `rank` | The category code that first found this product, and its 1-based position in Musinsa's list for that category and sort. |
| `product_id`, `url` | Musinsa's product number and the `https://www.musinsa.com/products/<product_id>` link. |
| `name`, `brand_id`, `brand_name`, `brand_url` | As Musinsa shows them. `brand_name` is usually Korean. |
| `gender` | `men`, `women` or `unisex`; **null** when Musinsa gives the product no gender (about one in five). |
| `list_price` | The tag price before any discount. |
| `price`, `discount_percent` | The price after Musinsa's own markdown, and the markdown as a whole percent. `discount_percent` is 0 when there is none, and then `price` equals `list_price`. |
| `coupon_price`, `coupon_percent` | The price after a coupon and the coupon's percent. **Null** when the product has no coupon, which is most products. |
| `extra_discount` | Further won taken off `price` at checkout. 0 when none. |
| `final_price`, `final_discount_percent` | The lowest price a buyer pays: `coupon_price` when there is a coupon, otherwise `price` less `extra_discount`. And the total percent off `list_price`. **Use `final_price` for price comparison.** |
| `is_lowest_price`, `has_option_price`, `is_sold_out`, `is_plus_delivery`, `is_ad` | Musinsa's own flags. `has_option_price` means options of the product carry different prices, so `price` is the figure shown on the listing. |
| `review_count`, `review_score` | Number of reviews and the average on Musinsa's **0 to 100** scale (96 is 4.8 of 5 stars). Musinsa sends a score of 0 for a product with no reviews; that is **null** here, with `review_count` 0. |
| `used_condition_grade` | Condition of a pre-owned item in the Used category (`S등급`, `A+등급`, `A등급`, `B등급`). Null for new goods. |
| `image_url` | The listing photo, 500 px wide. |

A field Musinsa did not send is `null`, never `0` or `""`.

### Pricing

Pay per event:

- **$0.002** per run (`actor-start`), charged only after your input is
  validated, so a run that fails on bad input costs nothing.
- **$0.00031** per product row written (`product-scraped`), i.e. $0.31 per
  1,000 products. A row that is not written is not charged.

### How it fetches

It calls the JSON API behind Musinsa's own category pages
(`api.musinsa.com/api2/dp/v1/plp/goods`), up to 100 products per request,
paging with `page`. Measured 2026-10-14: HTTP 200 and JSON with a Chrome TLS
fingerprint, no key or cookie needed, 30 consecutive 100-row pages in 4.7
seconds with no rate limit and no repeated product. Musinsa's edge (Cloudflare)
answers a client that sends no browser User-Agent with a 403 page, so the actor
fetches the way a browser does (Chrome's TLS fingerprint and headers); a refusal (403, 429, 5xx, or a 200 that is not
the list) is treated as the address being blocked, and the actor rotates to a
fresh one and retries. A request Musinsa rejects itself is permanent and is not
retried.

Things worth knowing, all measured:

- **Depth ceiling.** Musinsa will not serve a page past 1,000, so one category
  and sort gives at most 100,000 rows however many products it counts
  (`001` counts about 351,000). The actor stops there and logs it. To go
  deeper, use 6-digit sub-categories or a second sort: a new-arrivals feed only
  needs the first pages anyway.
- **Unknown sorts are ignored by Musinsa.** It answers any sort name it does not
  know with its default order and does not say so. Only the sorts measured to
  change the order are offered.
- **The list moves while it is read.** Products are added and removed all
  day (the count Musinsa reports drifted from 351,136 to 351,135 between two
  consecutive pages), so a product can repeat across pages or sit in two of
  your categories; the actor returns each product number once.
- **`maxItems` is per category.** Ten categories at 100 each is 1,000 rows.

# Actor input Schema

## `categories` (type: `array`):

Musinsa category codes, one per line, or a musinsa.com/category/... link. Each is listed separately. A 3-digit code is a top-level category: 001 tops, 002 outerwear, 003 pants, 100 dresses and skirts, 004 bags, 103 shoes, 120 hats, 101 accessories, 026 underwear and homewear, 017 sports, 104 beauty, 102 digital and lifestyle, 122 food and health, 107 outlet, 105 boutique, 106 kids, 108 어스, 111 K-Connect, 109 used. A 6-digit code is a sub-category: 001001 short-sleeve tees, 001004 hoodies, 002001 blouson and MA-1, 003002 denim, 103004 sneakers, 004001 backpacks. A product listed under two categories is returned once, under the first. Musinsa answers a code that does not exist with an empty list, so a wrong code shows as 'no products' in the log.

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

Read at most this many products for each category. Musinsa serves 100 per page and 1,000 pages, so up to 100,000 are accepted, which is the deepest Musinsa will page into any one category and sort.

## `sort` (type: `string`):

The order Musinsa lists products in. 'New arrivals' is the newest-first feed for tracking launches; 'Biggest discount first' is the markdown feed. Musinsa silently ignores a sort name it does not know, so only the names measured to work are offered.

## `gender` (type: `string`):

Limit the listing to men's or women's products. Both choices also include Musinsa's unisex products, so 'men' and 'women' overlap.

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

Apify proxy (automatic datacenter exits) is the default and answered Musinsa on every probe. A refused request (403, 429) is retried from a fresh address, which is what the proxy is for.

## Actor input object example

```json
{
  "categories": [
    "001"
  ],
  "maxItems": 100,
  "sort": "NEW",
  "gender": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

No description

# 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 = {
    "categories": [
        "001"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/musinsa-products").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 = {
    "categories": ["001"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/musinsa-products").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 '{
  "categories": [
    "001"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/musinsa-products --silent --output-dataset

```

## MCP server setup

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

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/HAISbaNcg7wzcPje4/builds/5bQruch6GMflX0g3d/openapi.json