# Naver Shopping Scraper (`nice_dev/naver-shopping-scraper`) Actor

Scrape Naver Shopping products by keyword or search URL: price, discount, rating, reviews, store, delivery, category. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/nice_dev/naver-shopping-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** E-commerce, MCP servers
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### 🛒 What is Naver Shopping Scraper?

**Naver Shopping Scraper** extracts **products from [Naver Shopping](https://search.shopping.naver.com)**, Korea's biggest shopping search: **price and discount, rating and reviews, store, delivery, stock, category and price-comparison catalog**, for any keyword or Naver Shopping search URL. It works as a **Naver Shopping API alternative**: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Type a **keyword** (`노트북`) or paste a Naver Shopping search URL, click **Start**, and download the products in JSON, CSV or Excel. No login, nothing to set up, and it is **fast: about 100 products in 3 seconds, 12,000 in about a minute** in our test runs. It goes **beyond Naver's 10,000 products per keyword**, finds the rank of your own products or stores, and can return only the new products and the price changes since the last run.

### 📋 What data can you extract from Naver Shopping?

One item per product, 91 fields:

| Category | What you get |
| --- | --- |
| 🏷️ **Product** | name, Naver product number, store product number, product link (desktop and mobile), photos |
| 💰 **Price** | price after discount, price before discount, discount %, Naver's unit price and its unit — `598000 KRW, 37 % off` |
| ⭐ **Reviews** | average rating, number of reviews, rating and reviews of the last 6 months — `4.77, 14,626 reviews` |
| 📦 **Stock** | units in stock, smallest quantity per order |
| 🏪 **Store** | store name, address and link, store grade, Naver certification, Brand Store, individual seller or business, Naver Pay seller number |
| 🚚 **Delivery** | delivery fee, free delivery, fast delivery (today, guaranteed arrival date), ships-from address, overseas product, customs fees |
| 🗂️ **Category** | category numbers and Korean names from the top level down — `디지털/가전 > 노트북` |
| 🔗 **Catalog** | Naver price-comparison catalog, number of offers, purchase options, competing offers |
| 🎁 **Promotions** | promotion tags (live, coupon…), gift, new product, set, fresh food, luxury and other Naver flags |
| 📈 **Rank and search** | position in the results (1 = first), sort order, keyword, total products Naver counts for the search |
| 🔔 **Monitoring** | new product or price drop / rise, previous price, change in %, price history of your runs |

Every field, with an example, is listed in the **Output** section below.

### ✅ Why use Naver Shopping Scraper?

- 🚀 **Fast**: about 100 products in 3 seconds, 12,000 different products in about a minute in our test runs.
- 🔓 **More than 10,000 products per keyword**: Naver stops every search at 10,000 products. The Actor reads the same keyword again in the other sort orders and keeps only the products not seen yet (on by default, free).
- 🎯 **Track your rank**: give your **Product IDs to track** or your **Stores**, and the Actor returns their position for each keyword — and stops as soon as all your products are found (1 results page instead of 600 in our tests).
- 🧹 **15 filters**: price, category (number or Korean name), rating, reviews, free or fast delivery, Brand Stores, certified stores, individual sellers or businesses, overseas products, stores, product IDs, excluded words — plus Naver's own brand and manufacturer filters.
- 🔔 **Monitoring built in**: tick **Only new products**, schedule the Actor, and each run returns (and charges) only what it has never delivered before. Add **price changes** to get back the products whose price moved, with the previous price.
- 🗂️ **Several searches in one run**: many keywords or search URLs, with a cap per search; a product found by several searches is saved once.
- 🔌 API, scheduling, monitoring, integrations (Make, Zapier, n8n, Google Sheets…), proxy rotation and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to scrape Naver Shopping

1. Create a free Apify account.
2. Open **Naver Shopping Scraper** and type a **Search keyword** (e.g. `노트북`). Korean keywords return far more products than English ones.
3. Or paste your own Naver Shopping search URLs into **Start URLs**: the keyword, the sort order, the rating 4.8+ filter and the brand and manufacturer filters of the URL are kept, pagination is automatic.
4. Set **Max products** (100 by default, 0 = no limit) — and **Max products per search** when you run several searches — then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to scrape Naver Shopping?

This Actor uses **pay per event** pricing: you pay for each product saved, plus a small fee per run start. See the **Pricing** tab for every amount.

- **Price changes** (**Also products whose price changed**): one charge for each product already delivered that comes back because its price moved by at least **Minimum price change (%)**, on top of the product. A new product costs its normal product price only.
- **Filter check**: the filters Naver does not offer (price, category, rating, delivery, store, excluded words, **Product IDs to track**) are applied by the Actor on every product it reads. A product that passes them costs its normal price; a product a filter drops costs a small filter fee instead, so filtering never costs more than taking everything.

A product you keep never costs a filter fee. Price changes are an option, unticked by default: nothing is charged for them unless you tick it. With **Only new products**, the products already delivered are skipped and not charged. Platform usage (compute, proxy) is included in the price.

### ⚙️ Input

```json
{
    "query": "노트북",
    "maxItems": 200,
    "sort": "REVIEW"
}
```

Several searches, a cap per search, filters, only the products not delivered before:

```json
{
    "query": "노트북",
    "searchQueries": ["마우스", "키보드"],
    "maxItemsPerQuery": 50,
    "maxItems": 0,
    "minPrice": 500000,
    "maxPrice": 2000000,
    "minRating": 4.5,
    "freeDeliveryOnly": true,
    "excludeKeywords": ["중고"],
    "onlyNew": true,
    "stateKey": "laptops-daily"
}
```

Or with your own Naver Shopping search URLs:

```json
{
    "startUrls": [
        { "url": "https://search.shopping.naver.com/ns/search?query=노트북&sort=REVIEW" },
        { "url": "https://search.shopping.naver.com/ns/search?query=립스틱" }
    ],
    "maxItems": 500
}
```

Track where your products sit for a keyword:

```json
{
    "query": "노트북",
    "targetProductIds": ["84417974537", "87642952896"],
    "maxItems": 0
}
```

| Field | Notes |
| --- | --- |
| `query`, `searchQueries` | Free-text search, exactly as typed on Naver Shopping (`노트북`); `searchQueries` adds up to 100 more keywords, one search each. Ignored when `startUrls` is set. |
| `startUrls` | Naver Shopping search URLs (`https://search.shopping.naver.com/ns/search?query=노트북&sort=REVIEW`), up to 1,000 search URLs. Product, catalog and store pages are not accepted. |
| `maxItems` | Stop after this many products for the whole run (`0` = unlimited). |
| `maxItemsPerQuery` | Cap for EACH search (keyword or search URL). `0` = no per-search cap. |
| `sort`, `combineSorts` | Sort order: `REL` (relevance, default), `LOW_PRICE`, `HIGH_PRICE`, `REVIEW`, `RECENT`, `PURCHASE`. `combineSorts` (on by default) reads the other sort orders once a search reaches Naver's limit. |
| `brandIds`, `makerIds` | Naver's own brand and manufacturer filters: the `brandIds` / `makerIds` number of a filtered Naver Shopping URL (`13363`). |
| `minPrice`, `maxPrice` | Price range in Korean won, on the price after discount. |
| `minRating`, `minReviews` | Smallest rating out of 5 (`4.8` or more also uses Naver's own 'rating 4.8+' filter) and smallest number of reviews. |
| `categories` | Category number (`50000151`) or Korean name (`노트북`, `화장품/미용`), at any level. A name the Actor does not know is refused at the start, with suggestions. |
| `freeDeliveryOnly`, `fastDeliveryOnly`, `brandStoresOnly`, `certifiedStoresOnly`, `privateSellersOnly`, `excludeIndividualSellers`, `excludeOverseas` | Free delivery, fast delivery, official Brand Stores, stores certified by Naver, individual sellers only, businesses only, no overseas products. |
| `stores` | Store name as shown on Naver, store ID (`hanloven`) or store address (`samsung_mall`, `https://smartstore.naver.com/samsung_mall`). |
| `targetProductIds` | Up to 500 product IDs: Naver product number or store product number (`84417974537`). The search stops once all of them are found. |
| `excludeKeywords` | Drop the products whose name contains one of these words (`중고`, case ignored). |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the products never delivered under this memory key (`laptops-daily`); `resetState` forgets the memory. |
| `includePriceChanges`, `minPriceChangePercent` | Paid option, with `onlyNew`: also the products already delivered whose price moved by at least `minPriceChangePercent` (1 % by default). |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

One real product from a test run, shortened to 29 of its 91 fields:

```json
{
    "id": "84417974537",
    "productId": "6873474215",
    "url": "https://smartstore.naver.com/basic-s/products/6873474215",
    "title": "베이직스 베이직북14 사무용 가벼운 업무용 인강용 미니 노트북 14인치 8GB 256GB",
    "imageUrl": "https://shopping-phinf.pstatic.net/main_8441797/84417974537.15.jpg",
    "price": 598000,
    "originalPrice": 959000,
    "discountPercent": 37,
    "currency": "KRW",
    "rating": 4.77,
    "reviewCount": 14626,
    "stockQuantity": 124,
    "storeName": "베이직스 스토어",
    "storeSlug": "basic-s",
    "storeGrade": "PREMIUM",
    "certifiedStoreType": "OFFICIAL_BRAND_MALL",
    "isBrandStore": true,
    "deliveryFee": 0,
    "freeDelivery": true,
    "fastDeliveryType": "ARRIVAL_GUARANTEE",
    "categoryPath": "디지털/가전 > 노트북",
    "catalogId": "55693208466",
    "catalogSellerCount": 1,
    "rank": 2,
    "sort": "REL",
    "searchQuery": "노트북",
    "searchTotal": 3321223,
    "searchUrl": "https://search.shopping.naver.com/ns/search?query=%EB%85%B8%ED%8A%B8%EB%B6%81",
    "scrapedAt": "2026-10-15T09:30:58.274Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. A field Naver does not give for a product is `null` (or `[]` for a list), never left out.

#### All 91 fields

| Fields | What you get |
| --- | --- |
| `id`, `productId`, `originalProductId`, `url`, `mobileUrl`, `title` | **Product**: `84417974537`, `6873474215`, the seller's origin number, the product page on SmartStore, Brand Stores included (desktop, mobile; a rental keeps its contract in the link), the name |
| `imageUrl`, `images` | first photo, every photo of the results |
| `price`, `originalPrice`, `discountPercent`, `unitPrice`, `capacityUnit`, `currency` | **Price**: `598000`, `959000`, `37`, Naver's unit price (most often the same as the price before discount, so not a price per gram) and the unit it names (`100g`, mostly food and cosmetics), `KRW`; for a rental (`saleType` `RENTAL`) the price is per month |
| `rating`, `reviewCount`, `rating6Months`, `reviewCount6Months` | **Reviews**: `4.77`, `14626`, the same for the last 6 months |
| `stockQuantity`, `minPurchaseQuantity`, `maxPurchaseQuantity` | **Stock**: `124`, `1`; the largest quantity per order is always `null` today (Naver's search results do not give it) |
| `storeName`, `storeId`, `storeSlug`, `storeUrl`, `storeSeq`, `channelNo`, `naverPaySellerNo` | **Store**: `베이직스 스토어`, account ID, address `basic-s`, home page, Naver store number, channel and Naver Pay seller numbers |
| `storeGrade`, `certifiedStoreType`, `isBrandStore`, `isIndividualSeller`, `isOverseas` | `PREMIUM`, `OFFICIAL_BRAND_MALL`, official Brand Store, individual seller, shipped from abroad |
| `deliveryFee`, `freeDelivery`, `fastDeliveryType`, `deliveryFilters`, `deliveryMethods`, `shipFromAddress`, `membershipFreeDelivery`, `customsDutySeparate`, `customsServiceFeeSeparate`, `orderClosedTime` | **Delivery**: `0`, `true`, `ARRIVAL_GUARANTEE`, Naver delivery tags, `DELIVERY`, ships-from address, free for Naver Plus members, customs paid apart, same-day cut-off time (Korean time) |
| `categoryId`, `categoryIds`, `categoryPath`, `categoryNames` | **Category**: `50000151`, every level's number, `디지털/가전 > 노트북`, every level's Korean name |
| `catalogId`, `catalogName`, `catalogSellerCount`, `catalogUrl`, `matchType`, `catalogOptions`, `otherOffers`, `catalogMatchingId`, `catalogChildId`, `catalogPickCandidateIds` | **Catalog**: Naver price-comparison catalog, its name, number of offers and page, `WINNER`, purchase options (name, price, delivery fee), competing offers (store, price), Naver's catalog ids |
| `promotions`, `promotionIds`, `hasGift`, `exceptBenefitTypes`, `isSuperPointProduct` | **Promotions**: `LIVE`, `COUPON`…, their ids, gift, benefits that do not apply, super points |
| `isNewProduct`, `isGroupProduct`, `isFreshProduct`, `productType`, `saleType`, `goodsType`, `windowType`, `authenticationType`, `standardProductName`, `standardGroupId`, `optionCount`, `colors` | **Product type**: new, set, fresh food, `NORMAL`, `DEFAULT`, Naver's shopping window (`BEAUTY`, `FASHION`…), normalised name, group of identical products, number of options, colour chips |
| `isLoungeProduct`, `isHighEndProduct`, `isKurlyProduct`, `isBranchProduct`, `isCustomProduct`, `isKnockitProduct`, `isPs` | other Naver flags: brand lounge, luxury, sold by Kurly, store branch, made to order |
| `rank`, `sort`, `searchQuery`, `searchTotal`, `searchUrl`, `scrapedAt` | **Rank and search**: `2`, `REL`, `노트북`, `3321223`, the Naver Shopping search page, ISO timestamp |
| `changeType`, `previousPrice`, `priceChangePercent`, `priceHistory` | **Monitoring** (with **Only new products** and **Also products whose price changed**): `new`, `price_drop` or `price_rise`, the previous price, the change in %, price, rating and reviews at each of your runs, dated by day in Korea |

### 💡 Tips

#### How to get more results

Naver shows at most 10,000 products per search and per sort order. Keep **Go beyond 10,000 products per keyword** (`combineSorts`) ticked: when a search reaches that limit before your caps, the Actor reads the same keyword again in the other sort orders, one after the other, out of the 6 sort orders, and keeps only the products not seen yet. In our tests, `노트북` gave 12,000 different products in about a minute. Korean keywords return far more products than English ones (`노트북` rather than `laptop`). The **Newest** order reaches only the recent products, a much shorter list than the other orders.

#### How to reduce costs

The price is per product, so the levers are `maxItems`, `maxItemsPerQuery`, the filters (a filtered-out product costs at most the filter fee, never the price of a product) and `onlyNew` for recurring runs (you never pay twice for the same product). With a **Max price** and the **Lowest price** order, the search stops once a whole results page is clearly above your price (likewise **Min price** with **Highest price**).

#### Track the rank of your products or stores

Fill **Product IDs to track** (`targetProductIds`, the Naver product number of the `id` field or the store product number) or **Stores**: only those products are saved, each with its `rank` for the keyword and the sort order. With product IDs, a search stops as soon as all of them are found. Schedule the run daily to follow your position over time; the rank of a product can move by one place between two runs, as Naver reorders its results.

#### Several searches in one run

Fill **More search keywords** (up to 100 more keywords) or paste several search URLs into **Start URLs**: each is a search of its own. A product found by several searches is saved — and charged — once. Set `maxItemsPerQuery` to give every search its own cap: without it the first searches can use up the whole `maxItems` budget.

#### Monitoring: only the new products

Tick **Only new products** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips the products already delivered: they are not saved and not charged. The memory lives in a named key-value store of your account (`naver-shopping-scraper-seen`, up to 150,000 products per key) and is only updated with products that really reached the dataset, so a failed run never hides anything. Give each schedule its own `stateKey` (two schedules sharing a key would hide each other's products), and tick `resetState` once to start over. With the **Newest** order, a search stops once it meets 500 products in a row you already have (fewer under a cap); with the other orders, the run reads on and skips them.

#### Price changes

Tick **Also products whose price changed** (`includePriceChanges`, a paid option) with **Only new products**: each run also returns the products already delivered whose price after discount went up or down by at least the **Minimum price change** (1 % by default), with `changeType` (`price_drop` or `price_rise`), `previousPrice`, `priceChangePercent` and the price history of the last 30 runs that saw the product. A change under your threshold is neither returned nor charged. The prices of at least 25,000 products per memory key are kept; past that, the products not met for the longest are forgotten and learned again, never reported as a change. A product is compared only when the run meets it again in its search results.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per Naver Shopping product. Actor id: `nice_dev/naver-shopping-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/naver-shopping-scraper`.

Smallest input, for a cheap first call:

```json
{
    "query": "노트북",
    "maxItems": 10
}
```

Key output fields: `url`, `title`, `price`, `discountPercent`, `rating`, `reviewCount`, `storeName` and `rank`.

Cost: see the pricing section above (one price per product saved). Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Naver Shopping?

The Actor only reads what Naver Shopping shows publicly to any anonymous visitor in its search results. It logs in to nothing and solves no captcha. Results can contain personal data — the store name or ships-from address of an individual seller — which is protected by GDPR and by Korea's privacy law: do not store it without a legitimate reason. You are responsible for using the data in compliance with Naver's Terms of Use and applicable law. This Actor is not affiliated with Naver.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Is the data safe to open in Excel or to show on a web page?

Product and store names are the sellers' own words, copied as they are. None of the 985 products of our test runs had a name starting with `-`, `+`, `=` or `@`, but a seller can write one: Excel and Google Sheets may read such a cell of a CSV file as a formula. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. On a web page, escape every field like any text written by a stranger.

#### Known limitations

- Review texts and the full product page (stock per option, specifications, seller record) are not included: you get the rating, the review counts and everything the search results show.
- `maxPurchaseQuantity` is always `null` today: Naver's search results give only the smallest quantity per order.
- A Naver Shopping search URL has no page number: a pasted URL is always read from its first product (use `maxItems` to stop earlier), and two URLs of the same search are read once.
- Only search URLs are accepted in **Start URLs**: a product, catalog or store page is refused at the start, with the reason.
- Naver can reorder its results while a big search is read: the run summary then tells how many products were seen twice, and a few may be missing.
- The total Naver announces for a search (`searchTotal`) can be a little higher than the products it really gives.
- Two runs sharing the same `stateKey` at the same time may both return the same new product.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options).

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the products already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the products it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the products of its last 2 seconds once more.

#### Something doesn't work?

The last line of the log counts the products saved and filtered out, and the requests that failed after every retry. Those requests are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause.

If Naver changes its results, you are told instead of paying for blank rows. If the first 20 products read all lack the same field (name, price, store, category…), the run saves nothing more, stops and fails, and its last message names the missing field: at most those first products are charged. A run of fewer products (a scheduled `onlyNew` run that finds a few new ones, a small **Max products**) is checked at its end, from 5 products: its products are already saved, and the run fails with the missing field instead of ending green.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which requests failed and why.

# Actor input Schema

## `startUrls` (type: `array`):

Naver Shopping search URLs (`https://search.shopping.naver.com/ns/search?query=노트북&sort=REVIEW`): the keyword, the sort order and the filters the Actor understands in the URL are kept, pagination is automatic. When this list is not empty, **Search keyword** and **More search keywords** are ignored; filters, caps and monitoring still apply. Max 1 000 URLs.

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

Free-text search, exactly as typed on Naver Shopping. Korean keywords return far more products than English ones (e.g. `노트북` rather than `laptop`).

## `searchQueries` (type: `array`):

Several keywords in one run: one search per keyword. Added to **Search keyword**; products found by several searches are saved once.

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

Maximum number of products to save for the whole run (after deduplication and filters). 0 = no limit.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH search (keyword or search URL), so that the first search cannot use up the whole **Max products** budget. 0 = no per-search cap.

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

Order of the search results, as on Naver Shopping. Each order reaches a different set of products (Naver shows at most 10,000 products per search and per order). `Newest` reaches only the recent products, a much shorter list than the other orders (about 15,000 instead of 3 million for 노트북).

## `combineSorts` (type: `boolean`):

Naver stops a search at 10,000 products. When a search reaches that limit before your caps, the Actor reads the same keyword again in the other sort orders, one after the other, and keeps only the products not seen yet. With a **Max price** the Lowest price order is read right after your own sort order and, once it passes your price, nothing more is read (likewise **Min price** with Highest price). Each product is still saved only once, even when several orders find it.

## `brandIds` (type: `array`):

Only products of these Naver brand numbers (Naver's own brand filter, sent to Naver). The number is the `brandIds` value of a filtered Naver Shopping URL.

## `makerIds` (type: `array`):

Only products of these Naver manufacturer numbers (Naver's own manufacturer filter, sent to Naver). The number is the `makerIds` value of a filtered Naver Shopping URL.

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

Only products from this price in Korean won, read on the price after discount. With the **Highest price** order, the search stops once a whole results page is clearly below it.

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

Only products up to this price in Korean won, read on the price after discount. With the **Lowest price** order, the search stops once a whole results page is clearly above it.

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

Only products in one of these Naver Shopping categories, at any level: the category number (`50000151`) or its Korean name (`노트북`, `화장품/미용`). Empty = all categories.

## `minRating` (type: `number`):

Only products rated at least this (out of 5). 4.8 or more also uses Naver's own 'rating 4.8+' filter. Products without reviews are left out.

## `minReviews` (type: `integer`):

Only products with at least this many reviews.

## `freeDeliveryOnly` (type: `boolean`):

Only products shipped for free.

## `fastDeliveryOnly` (type: `boolean`):

Only products with Naver's fast delivery (same-day delivery or a guaranteed arrival date).

## `brandStoresOnly` (type: `boolean`):

Only products sold in an official Naver Brand Store.

## `certifiedStoresOnly` (type: `boolean`):

Only products of stores certified by Naver (official mall, certified mall).

## `privateSellersOnly` (type: `boolean`):

Only products sold by individuals (not by a registered business).

## `excludeIndividualSellers` (type: `boolean`):

Drop the products sold by individuals: businesses only.

## `excludeOverseas` (type: `boolean`):

Drop the products shipped from abroad (direct purchase).

## `stores` (type: `array`):

Only products of these stores: store name as shown on Naver, store ID (`hanloven`) or store address (`samsung_mall`, `https://smartstore.naver.com/samsung_mall`). With the `rank` field, this tracks where a store sits for a keyword.

## `targetProductIds` (type: `array`):

Only these products: Naver product number (`nvMid`, the `id` field) or store product number (`productId`). With the `rank` field, this tracks where your product sits for a keyword.

## `excludeKeywords` (type: `array`):

Drop the products whose title contains one of these words (case ignored).

## `onlyNew` (type: `boolean`):

Skip the products that a previous run (same **Memory key**) already delivered: they are not saved and not charged. First run = everything is new.

## `includePriceChanges` (type: `boolean`):

With **Only new products**: also return the products already delivered whose price went up or down since the last run, with the previous price, the change in % and the price history of your runs. Charged per changed product (event `price-change`).

## `minPriceChangePercent` (type: `number`):

With **Also products whose price changed**: a product comes back only if its price after discount moved by at least this many % since the last time it was delivered. Under this %, the move is neither returned nor charged. 0 = every change, down to 1 won.

## `stateKey` (type: `string`):

Name of the memory used by **Only new products**. Give each schedule / task its own key (e.g. `laptops-daily`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every product again. Untick it afterwards.

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

Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

## `maxConcurrency` (type: `integer`):

Maximum number of requests processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to the site in any 60 seconds, all of them counted: every results page of 100 products. A budget, not an even pace: up to this many can leave at once when the minute starts (spread them with the minimum delay below). Lower it if the site answers HTTP 429 / 403 in the log.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. The default 400 means at most 150 requests a minute; Naver turns away an address that sends about 2 requests a second without a pause. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked as failed. Behind a proxy, a request the site turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "query": "노트북",
  "searchQueries": [],
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "sort": "REL",
  "combineSorts": true,
  "brandIds": [],
  "makerIds": [],
  "categories": [],
  "freeDeliveryOnly": false,
  "fastDeliveryOnly": false,
  "brandStoresOnly": false,
  "certifiedStoresOnly": false,
  "privateSellersOnly": false,
  "excludeIndividualSellers": false,
  "excludeOverseas": false,
  "stores": [],
  "targetProductIds": [],
  "excludeKeywords": [],
  "onlyNew": false,
  "includePriceChanges": false,
  "minPriceChangePercent": 1,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 120,
  "minRequestIntervalMs": 400,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

## `results` (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 = {
    "query": "노트북",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/naver-shopping-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": "노트북",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/naver-shopping-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": "노트북",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/naver-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/naver-shopping-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/exPcyyTuM0Lprhecf/builds/2cSEAWatqupJupBmF/openapi.json